Removed ValueTask generally where not needed

Removed relationships from audit log

PostFundManagement.Application/Abstractions/S3ServiceBase.cs

@@ -12,8 +12,8 @@ public abstract class S3ServiceBase(IAmazonS3 amazonS3)
 
     public string GenerateCdnUrl(string fileKey) => $"{CdnBaseUrl}/{fileKey}";
 
-    public virtual async ValueTask<Result<string>> GeneratePresignedUrlAsync(string fileKey, TimeSpan duration, string? contentType = null, CancellationToken cancellationToken = default) =>
-        await Result.Try((Func<ValueTask<Result<string>>>)(async () =>
+    public virtual async Task<Result<string>> GeneratePresignedUrlAsync(string fileKey, TimeSpan duration, string? contentType = null, CancellationToken cancellationToken = default) =>
+        await Result.Try((Func<Task<Result<string>>>)(async () =>
         {
             if (string.IsNullOrWhiteSpace(BucketName))
                 return Result.Fail(ValidationError.Create("Bucket name is not configured."));
@@ -51,8 +51,8 @@ public abstract class S3ServiceBase(IAmazonS3 amazonS3)
             : $"{cleanSubPath}/{fileHash.ToLower(CultureInfo.InvariantCulture)}_{fileName}";
     }
 
-    public virtual async ValueTask<Result<string>> UploadFileAsync(string fileName, string subPath, Stream fileStream, string contentType, CancellationToken cancellationToken = default) =>
-        await Result.Try((Func<ValueTask<Result<string>>>)(async () =>
+    public virtual async Task<Result<string>> UploadFileAsync(string fileName, string subPath, Stream fileStream, string contentType, CancellationToken cancellationToken = default) =>
+        await Result.Try((Func<Task<Result<string>>>)(async () =>
         {
             if (string.IsNullOrWhiteSpace(BucketName))
                 return Result.Fail<string>(ValidationError.Create("Bucket name is not configured."));
@@ -92,8 +92,8 @@ public abstract class S3ServiceBase(IAmazonS3 amazonS3)
                 : Result.Ok(fileKey);
         }));
 
-    public virtual async ValueTask<Result> DeleteFileAsync(string fileKey, CancellationToken cancellationToken = default) =>
-        await Result.Try((Func<ValueTask<Result>>)(async () =>
+    public virtual async Task<Result> DeleteFileAsync(string fileKey, CancellationToken cancellationToken = default) =>
+        await Result.Try((Func<Task<Result>>)(async () =>
         {
             if (string.IsNullOrWhiteSpace(BucketName))
                 return Result.Fail(NotFoundError.Create("Bucket name is not configured."));

PostFundManagement.Application/Abstractions/Services/ICommunicationsService.cs

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

PostFundManagement.Application/Abstractions/Services/IEvidenceService.cs

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

PostFundManagement.Application/Abstractions/Services/IExecutionService.cs

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

PostFundManagement.Application/Abstractions/Services/IGovernanceService.cs

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

PostFundManagement.Application/Abstractions/Services/IGrantsService.cs

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

PostFundManagement.Application/Abstractions/Services/IIdentityService.cs

@@ -5,5 +5,5 @@ namespace PostFundManagement.Application.Abstractions.Services;
 public interface IIdentityService
 {
     [Audit]
-    ValueTask<Result> UserIsAuthorisedAsync(Guid userId, CancellationToken cancellationToken = default);
+    Task<Result> UserIsAuthorisedAsync(Guid userId, CancellationToken cancellationToken = default);
 }

PostFundManagement.Application/Abstractions/Services/IProjectService.cs

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

PostFundManagement.Application/Abstractions/Services/IToolService.cs

@@ -2,5 +2,5 @@
 
 public interface IToolService
 {
-    ValueTask<Result<string>> EncodeLong(long id, CancellationToken cancellationToken);
+    Task<Result<string>> EncodeLong(long id, CancellationToken cancellationToken);
 }

PostFundManagement.Application/Abstractions/Services/IUserService.cs

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

PostFundManagement.Application/Interceptors/AuditInterceptor.cs

@@ -73,7 +73,7 @@ public sealed class AuditInterceptor(AuditService auditService, IHttpContextAcce
         {
             var genericDef = returnType.GetGenericTypeDefinition();
 
-            if (genericDef == typeof(Task<>) || genericDef == typeof(ValueTask<>))
+            if (genericDef == typeof(Task<>) || genericDef == typeof(Task<>))
                 innerType = returnType.GetGenericArguments()[0];
         }
 

PostFundManagement.Application/Services/Communications/CommunicationsCacheService.cs

@@ -3,6 +3,7 @@ using PostFundManagement.Application.Abstractions.Services;
 using PostFundManagement.Application.Extensions;
 using PostFundManagement.Application.Services.Shared;
 using PostFundManagement.Domain;
+using PostFundManagement.Domain.Attributes;
 using PostFundManagement.Domain.Models;
 using static PostFundManagement.Domain.Extensions.Constants;
 
@@ -11,8 +12,8 @@ namespace PostFundManagement.Application.Services.Communications;
 public sealed class CommunicationsCacheService(CommunicationsService service, IDistributedCache cache,
     IFeatureManager featureManager) : ServiceCacheBase, ICommunicationsService
 {
-    public async ValueTask<Result<Invite>> GetApplicantInviteAsync(Guid applicantUserId, CancellationToken cancellationToken = default) =>
-        await Result.Try((Func<ValueTask<Result<Invite>>>)(async () =>
+    public async Task<Result<Invite>> GetApplicantInviteAsync(Guid applicantUserId, CancellationToken cancellationToken = default) =>
+        await Result.Try((Func<Task<Result<Invite>>>)(async () =>
         {
             if (!await featureManager.IsEnabledAsync(ServiceCachingFeature))
                 return await service.GetApplicantInviteAsync(applicantUserId, cancellationToken);
@@ -33,8 +34,8 @@ public sealed class CommunicationsCacheService(CommunicationsService service, ID
             return Result.Ok(cached!.FromJson<Invite>());
         }));
 
-    public async ValueTask<Result<Invite[]>> GetApplicantInvitesAsync(Guid applicantUserId, CancellationToken cancellationToken = default) =>
-        await Result.Try((Func<ValueTask<Result<Invite[]>>>)(async () =>
+    public async Task<Result<Invite[]>> GetApplicantInvitesAsync(Guid applicantUserId, CancellationToken cancellationToken = default) =>
+        await Result.Try((Func<Task<Result<Invite[]>>>)(async () =>
         {
             if (!await featureManager.IsEnabledAsync(ServiceCachingFeature))
                 return await service.GetApplicantInvitesAsync(applicantUserId, cancellationToken);
@@ -57,8 +58,8 @@ public sealed class CommunicationsCacheService(CommunicationsService service, ID
             return Result.Ok(cached.FromJson<Invite[]>());
         }));
 
-    public async ValueTask<Result<Invite[]>> GetInvitesAsync(Pagination pagination, CancellationToken cancellationToken = default) =>
-        await Result.Try((Func<ValueTask<Result<Invite[]>>>)(async () =>
+    public async Task<Result<Invite[]>> GetInvitesAsync(Pagination pagination, CancellationToken cancellationToken = default) =>
+        await Result.Try((Func<Task<Result<Invite[]>>>)(async () =>
         {
             if (!await featureManager.IsEnabledAsync(ServiceCachingFeature))
                 return await service.GetInvitesAsync(pagination, cancellationToken);
@@ -81,6 +82,7 @@ public sealed class CommunicationsCacheService(CommunicationsService service, ID
             return Result.Ok(cached.FromJson<Invite[]>());
         }));
 
-    public async ValueTask<Result<Invite>> SendInviteAsync(InviteRequest request, Guid userId, CancellationToken cancellationToken = default) =>
+    [Audit]
+    public async Task<Result<Invite>> SendInviteAsync(InviteRequest request, Guid userId, CancellationToken cancellationToken = default) =>
         await service.SendInviteAsync(request, userId, cancellationToken);
 }

PostFundManagement.Application/Services/Communications/CommunicationsService.cs

@@ -9,8 +9,8 @@ namespace PostFundManagement.Application.Services.Communications;
 
 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 () =>
+    public async Task<Result<Invite>> SendInviteAsync(InviteRequest request, Guid userId, CancellationToken cancellationToken = default) =>
+        await Result.Try((Func<Task<Result<Invite>>>)(async () =>
         {
             await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
 
@@ -42,8 +42,8 @@ public sealed class CommunicationsService(IDbContextFactory<ApplicationDbContext
                 .ToResult(invite.Map());
         }));
 
-    public async ValueTask<Result<Invite[]>> GetInvitesAsync(Pagination pagination, CancellationToken cancellationToken = default) =>
-        await Result.Try((Func<ValueTask<Result<Invite[]>>>)(async () =>
+    public async Task<Result<Invite[]>> GetInvitesAsync(Pagination pagination, CancellationToken cancellationToken = default) =>
+        await Result.Try((Func<Task<Result<Invite[]>>>)(async () =>
         {
             await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
 
@@ -56,8 +56,8 @@ public sealed class CommunicationsService(IDbContextFactory<ApplicationDbContext
             return Result.Ok(invites.Select(i => i.Map()).ToArray());
         }));
 
-    public async ValueTask<Result<Invite>> GetApplicantInviteAsync(Guid applicantUserId, CancellationToken cancellationToken) =>
-        await Result.Try((Func<ValueTask<Result<Invite>>>)(async () =>
+    public async Task<Result<Invite>> GetApplicantInviteAsync(Guid applicantUserId, CancellationToken cancellationToken) =>
+        await Result.Try((Func<Task<Result<Invite>>>)(async () =>
         {
             await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
 
@@ -67,8 +67,8 @@ public sealed class CommunicationsService(IDbContextFactory<ApplicationDbContext
                 .ToResult(invite!.Map());
         }));
 
-    public async ValueTask<Result<Invite[]>> GetApplicantInvitesAsync(Guid applicantUserId, CancellationToken cancellationToken = default) =>
-        await Result.Try((Func<ValueTask<Result<Invite[]>>>)(async () =>
+    public async Task<Result<Invite[]>> GetApplicantInvitesAsync(Guid applicantUserId, CancellationToken cancellationToken = default) =>
+        await Result.Try((Func<Task<Result<Invite[]>>>)(async () =>
         {
             await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
 

PostFundManagement.Application/Services/Evidence/EvidenceCacheService.cs

@@ -3,6 +3,7 @@ using PostFundManagement.Application.Abstractions.Services;
 using PostFundManagement.Application.Extensions;
 using PostFundManagement.Application.Services.Shared;
 using PostFundManagement.Domain;
+using PostFundManagement.Domain.Attributes;
 using PostFundManagement.Domain.Models;
 using static PostFundManagement.Domain.Extensions.Constants;
 
@@ -11,17 +12,20 @@ namespace PostFundManagement.Application.Services.Evidence;
 public sealed class EvidenceCacheService(EvidenceService service, IDistributedCache cache,
     IFeatureManager featureManager) : ServiceCacheBase, IEvidenceService
 {
-    public async ValueTask<Result> CreateEvidenceAsync(Guid userId, IFormCollection form, IFormFile file, CancellationToken cancellationToken = default) =>
+    [Audit]
+    public async Task<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) =>
+    [Audit]
+    public async Task<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) =>
+    [Audit]
+    public async Task<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 () =>
+    public async Task<Result<Domain.Models.Evidence>> GetEvidenceAsync(string evidenceId, CancellationToken cancellationToken = default) =>
+        await Result.Try((Func<Task<Result<Domain.Models.Evidence>>>)(async () =>
         {
             if (!await featureManager.IsEnabledAsync(ServiceCachingFeature))
                 return await service.GetEvidenceAsync(evidenceId, cancellationToken);
@@ -44,8 +48,8 @@ public sealed class EvidenceCacheService(EvidenceService service, IDistributedCa
             return Result.Ok(cached.FromJson<Domain.Models.Evidence>());
         }));
 
-    public async ValueTask<Result<Domain.Models.Evidence[]>> GetEvidenceFilesAsync(Pagination pagination, CancellationToken cancellationToken = default) =>
-        await Result.Try((Func<ValueTask<Result<Domain.Models.Evidence[]>>>)(async () =>
+    public async Task<Result<Domain.Models.Evidence[]>> GetEvidenceFilesAsync(Pagination pagination, CancellationToken cancellationToken = default) =>
+        await Result.Try((Func<Task<Result<Domain.Models.Evidence[]>>>)(async () =>
         {
             if (!await featureManager.IsEnabledAsync(ServiceCachingFeature))
                 return await service.GetEvidenceFilesAsync(pagination, cancellationToken);
@@ -68,8 +72,8 @@ public sealed class EvidenceCacheService(EvidenceService service, IDistributedCa
             return Result.Ok(cached.FromJson<Domain.Models.Evidence[]>());
         }));
 
-    public async ValueTask<Result<string>> GetEvidenceUrlAsync(string evidenceIdHash, CancellationToken cancellationToken = default) =>
-        await Result.Try((Func<ValueTask<Result<string>>>)(async () =>
+    public async Task<Result<string>> GetEvidenceUrlAsync(string evidenceIdHash, CancellationToken cancellationToken = default) =>
+        await Result.Try((Func<Task<Result<string>>>)(async () =>
         {
             if (!await featureManager.IsEnabledAsync(ServiceCachingFeature))
                 return await service.GetEvidenceUrlAsync(evidenceIdHash, cancellationToken);
@@ -92,8 +96,8 @@ public sealed class EvidenceCacheService(EvidenceService service, IDistributedCa
             return Result.Ok(cached);
         }));
 
-    public async ValueTask<Result<Indicator>> GetIndicatorAsync(string indicatorId, CancellationToken cancellationToken = default) =>
-        await Result.Try((Func<ValueTask<Result<Indicator>>>)(async () =>
+    public async Task<Result<Indicator>> GetIndicatorAsync(string indicatorId, CancellationToken cancellationToken = default) =>
+        await Result.Try((Func<Task<Result<Indicator>>>)(async () =>
         {
             if (!await featureManager.IsEnabledAsync(ServiceCachingFeature))
                 return await service.GetIndicatorAsync(indicatorId, cancellationToken);
@@ -116,8 +120,8 @@ public sealed class EvidenceCacheService(EvidenceService service, IDistributedCa
             return Result.Ok(cached.FromJson<Indicator>());
         }));
 
-    public async ValueTask<Result<Indicator[]>> GetIndicatorsAsync(Pagination pagination, CancellationToken cancellationToken = default) =>
-        await Result.Try((Func<ValueTask<Result<Indicator[]>>>)(async () =>
+    public async Task<Result<Indicator[]>> GetIndicatorsAsync(Pagination pagination, CancellationToken cancellationToken = default) =>
+        await Result.Try((Func<Task<Result<Indicator[]>>>)(async () =>
         {
             if (!await featureManager.IsEnabledAsync(ServiceCachingFeature))
                 return await service.GetIndicatorsAsync(pagination, cancellationToken);
@@ -140,8 +144,8 @@ public sealed class EvidenceCacheService(EvidenceService service, IDistributedCa
             return Result.Ok(cached.FromJson<Indicator[]>());
         }));
 
-    public async ValueTask<Result<Domain.Models.Evidence[]>> GetMilestoneEvidencesAsync(string milestoneIdHash, CancellationToken cancellationToken = default) =>
-        await Result.Try((Func<ValueTask<Result<Domain.Models.Evidence[]>>>)(async () =>
+    public async Task<Result<Domain.Models.Evidence[]>> GetMilestoneEvidencesAsync(string milestoneIdHash, CancellationToken cancellationToken = default) =>
+        await Result.Try((Func<Task<Result<Domain.Models.Evidence[]>>>)(async () =>
         {
             if (!await featureManager.IsEnabledAsync(ServiceCachingFeature))
                 return await service.GetMilestoneEvidencesAsync(milestoneIdHash, cancellationToken);
@@ -164,8 +168,8 @@ public sealed class EvidenceCacheService(EvidenceService service, IDistributedCa
             return Result.Ok(cached.FromJson<Domain.Models.Evidence[]>());
         }));
 
-    public async ValueTask<Result<Domain.Models.Evidence[]>> GetProjectEvidencesAsync(string projectIdHash, CancellationToken cancellationToken = default) =>
-        await Result.Try((Func<ValueTask<Result<Domain.Models.Evidence[]>>>)(async () =>
+    public async Task<Result<Domain.Models.Evidence[]>> GetProjectEvidencesAsync(string projectIdHash, CancellationToken cancellationToken = default) =>
+        await Result.Try((Func<Task<Result<Domain.Models.Evidence[]>>>)(async () =>
         {
             if (!await featureManager.IsEnabledAsync(ServiceCachingFeature))
                 return await service.GetProjectEvidencesAsync(projectIdHash, cancellationToken);
@@ -188,9 +192,11 @@ public sealed class EvidenceCacheService(EvidenceService service, IDistributedCa
             return Result.Ok(cached.FromJson<Domain.Models.Evidence[]>());
         }));
 
-    public async ValueTask<Result> RecordIndicatorActualAmountAsync(string indicatorIdHash, decimal amount, Guid userId, CancellationToken cancellationToken = default) =>
+    [Audit]
+    public async Task<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) =>
+    [Audit]
+    public async Task<Result> UpdateEvidenceAsync(UpdateEvidenceRequest request, Guid userId, CancellationToken cancellationToken = default) =>
         await service.UpdateEvidenceAsync(request, userId, cancellationToken);
 }

PostFundManagement.Application/Services/Evidence/EvidenceService.cs

@@ -12,8 +12,8 @@ namespace PostFundManagement.Application.Services.Evidence;
 public sealed class EvidenceService(IDbContextFactory<ApplicationDbContext> contextFactory, HashService hashService,
     [FromKeyedServices(Constants.GeneralBucketName)] IS3Service s3Service) : IEvidenceService
 {
-    public async ValueTask<Result> CreateEvidenceAsync(Guid userId, IFormCollection form, IFormFile file, CancellationToken cancellationToken = default) =>
-        await Result.Try((Func<ValueTask<Result>>)(async () =>
+    public async Task<Result> CreateEvidenceAsync(Guid userId, IFormCollection form, IFormFile file, CancellationToken cancellationToken = default) =>
+        await Result.Try((Func<Task<Result>>)(async () =>
         {
             if (!long.TryParse(form["projectId"], out var projectId) || !long.TryParse(form["milestoneId"], out var milestoneId) ||
                 !long.TryParse(form["indicatorId"], out var indicatorId) || !long.TryParse(form["activityId"], out var activityId) ||
@@ -49,8 +49,8 @@ public sealed class EvidenceService(IDbContextFactory<ApplicationDbContext> cont
             return Result.OkIf(await context.SaveChangesAsync(cancellationToken) > 0, CreateError.New);
         }));
 
-    public async ValueTask<Result> RecordIndicatorActualAmountAsync(string indicatorIdHash, decimal amount, Guid userId, CancellationToken cancellationToken = default) =>
-        await Result.Try((Func<ValueTask<Result>>)(async () =>
+    public async Task<Result> RecordIndicatorActualAmountAsync(string indicatorIdHash, decimal amount, Guid userId, CancellationToken cancellationToken = default) =>
+        await Result.Try((Func<Task<Result>>)(async () =>
         {
             var decodeResult = hashService.DecodeLongIdHash(indicatorIdHash);
 
@@ -68,8 +68,8 @@ public sealed class EvidenceService(IDbContextFactory<ApplicationDbContext> cont
             return Result.OkIf(changedTotal > 0, UpdateError.New);
         }));
 
-    public async ValueTask<Result<Indicator[]>> GetIndicatorsAsync(Pagination pagination, CancellationToken cancellationToken = default) =>
-        await Result.Try((Func<ValueTask<Result<Indicator[]>>>)(async () =>
+    public async Task<Result<Indicator[]>> GetIndicatorsAsync(Pagination pagination, CancellationToken cancellationToken = default) =>
+        await Result.Try((Func<Task<Result<Indicator[]>>>)(async () =>
         {
             await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
 
@@ -82,8 +82,8 @@ public sealed class EvidenceService(IDbContextFactory<ApplicationDbContext> cont
             return Result.Ok(indicators.Select(i => i.Map()).ToArray());
         }));
 
-    public async ValueTask<Result<Domain.Models.Evidence[]>> GetEvidenceFilesAsync(Pagination pagination, CancellationToken cancellationToken = default) =>
-        await Result.Try((Func<ValueTask<Result<Domain.Models.Evidence[]>>>)(async () =>
+    public async Task<Result<Domain.Models.Evidence[]>> GetEvidenceFilesAsync(Pagination pagination, CancellationToken cancellationToken = default) =>
+        await Result.Try((Func<Task<Result<Domain.Models.Evidence[]>>>)(async () =>
         {
             await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
 
@@ -96,8 +96,8 @@ public sealed class EvidenceService(IDbContextFactory<ApplicationDbContext> cont
             return Result.Ok(evidence.Select(i => i.Map()).ToArray());
         }));
 
-    public async ValueTask<Result> CreateMilestoneAsync(CreateMilestoneRequest request, Guid userId, CancellationToken cancellationToken = default) =>
-        await Result.Try((Func<ValueTask<Result>>)(async () =>
+    public async Task<Result> CreateMilestoneAsync(CreateMilestoneRequest request, Guid userId, CancellationToken cancellationToken = default) =>
+        await Result.Try((Func<Task<Result>>)(async () =>
         {
             await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
 
@@ -122,8 +122,8 @@ public sealed class EvidenceService(IDbContextFactory<ApplicationDbContext> cont
                 CreateError.Create("No record could be created."));
         }));
 
-    public async ValueTask<Result> CreateIndicatorAsync(CreateIndicatorRequest request, Guid userId, CancellationToken cancellationToken = default) =>
-        await Result.Try((Func<ValueTask<Result>>)(async () =>
+    public async Task<Result> CreateIndicatorAsync(CreateIndicatorRequest request, Guid userId, CancellationToken cancellationToken = default) =>
+        await Result.Try((Func<Task<Result>>)(async () =>
         {
             await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
 
@@ -145,8 +145,8 @@ public sealed class EvidenceService(IDbContextFactory<ApplicationDbContext> cont
             return Result.OkIf(await context.SaveChangesAsync(cancellationToken) > 0, CreateError.New);
         }));
 
-    public async ValueTask<Result<Indicator>> GetIndicatorAsync(string indicatorId, CancellationToken cancellationToken) =>
-        await Result.Try((Func<ValueTask<Result<Indicator>>>)(async () =>
+    public async Task<Result<Indicator>> GetIndicatorAsync(string indicatorId, CancellationToken cancellationToken) =>
+        await Result.Try((Func<Task<Result<Indicator>>>)(async () =>
         {
             var decodeResult = hashService.DecodeLongIdHash(indicatorId);
 
@@ -162,8 +162,8 @@ public sealed class EvidenceService(IDbContextFactory<ApplicationDbContext> cont
                 .ToResult(indicator!.Map());
         }));
 
-    public async ValueTask<Result<Domain.Models.Evidence>> GetEvidenceAsync(string evidenceId, CancellationToken cancellationToken = default) =>
-        await Result.Try((Func<ValueTask<Result<Domain.Models.Evidence>>>)(async () =>
+    public async Task<Result<Domain.Models.Evidence>> GetEvidenceAsync(string evidenceId, CancellationToken cancellationToken = default) =>
+        await Result.Try((Func<Task<Result<Domain.Models.Evidence>>>)(async () =>
         {
             var decodeResult = hashService.DecodeLongIdHash(evidenceId);
 
@@ -179,8 +179,8 @@ public sealed class EvidenceService(IDbContextFactory<ApplicationDbContext> cont
                 .ToResult(evidence!.Map());
         }));
 
-    public async ValueTask<Result<Domain.Models.Evidence[]>> GetMilestoneEvidencesAsync(string milestoneIdHash, CancellationToken cancellationToken = default) =>
-        await Result.Try((Func<ValueTask<Result<Domain.Models.Evidence[]>>>)(async () =>
+    public async Task<Result<Domain.Models.Evidence[]>> GetMilestoneEvidencesAsync(string milestoneIdHash, CancellationToken cancellationToken = default) =>
+        await Result.Try((Func<Task<Result<Domain.Models.Evidence[]>>>)(async () =>
         {
             var decodeResult = hashService.DecodeLongIdHash(milestoneIdHash);
 
@@ -199,8 +199,8 @@ public sealed class EvidenceService(IDbContextFactory<ApplicationDbContext> cont
             return Result.Ok(evidences.Select(e => e.Map()).ToArray());
         }));
 
-    public async ValueTask<Result<Domain.Models.Evidence[]>> GetProjectEvidencesAsync(string projectIdHash, CancellationToken cancellationToken = default) =>
-        await Result.Try((Func<ValueTask<Result<Domain.Models.Evidence[]>>>)(async () =>
+    public async Task<Result<Domain.Models.Evidence[]>> GetProjectEvidencesAsync(string projectIdHash, CancellationToken cancellationToken = default) =>
+        await Result.Try((Func<Task<Result<Domain.Models.Evidence[]>>>)(async () =>
         {
             var decodeResult = hashService.DecodeLongIdHash(projectIdHash);
 
@@ -219,8 +219,8 @@ public sealed class EvidenceService(IDbContextFactory<ApplicationDbContext> cont
             return Result.Ok(evidences.Select(e => e.Map()).ToArray());
         }));
 
-    public async ValueTask<Result> UpdateEvidenceAsync(UpdateEvidenceRequest request, Guid userId, CancellationToken cancellationToken = default) =>
-        await Result.Try((Func<ValueTask<Result>>)(async () =>
+    public async Task<Result> UpdateEvidenceAsync(UpdateEvidenceRequest request, Guid userId, CancellationToken cancellationToken = default) =>
+        await Result.Try((Func<Task<Result>>)(async () =>
         {
             await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
 
@@ -238,8 +238,8 @@ public sealed class EvidenceService(IDbContextFactory<ApplicationDbContext> cont
             return Result.OkIf(changedTotal > 0, UpdateError.New);
         }));
 
-    public async ValueTask<Result<string>> GetEvidenceUrlAsync(string evidenceIdHash, CancellationToken cancellationToken = default) =>
-        await Result.Try((Func<ValueTask<Result<string>>>)(async () =>
+    public async Task<Result<string>> GetEvidenceUrlAsync(string evidenceIdHash, CancellationToken cancellationToken = default) =>
+        await Result.Try((Func<Task<Result<string>>>)(async () =>
         {
             var decodeResult = hashService.DecodeLongIdHash(evidenceIdHash);
 

PostFundManagement.Application/Services/Execution/ExecutionCacheService.cs

@@ -3,6 +3,7 @@ using PostFundManagement.Application.Abstractions.Services;
 using PostFundManagement.Application.Extensions;
 using PostFundManagement.Application.Services.Shared;
 using PostFundManagement.Domain;
+using PostFundManagement.Domain.Attributes;
 using PostFundManagement.Domain.Models;
 using static PostFundManagement.Domain.Extensions.Constants;
 
@@ -11,17 +12,20 @@ namespace PostFundManagement.Application.Services.Execution;
 public sealed class ExecutionCacheService(ExecutionService service, IDistributedCache cache,
     IFeatureManager featureManager) : ServiceCacheBase, IExecutionService
 {
-    public async ValueTask<Result> ApproveDisbursementAsync(string disbursementIdHash, Guid userId, CancellationToken cancellationToken = default) =>
+    [Audit]
+    public async Task<Result> ApproveDisbursementAsync(string disbursementIdHash, Guid userId, CancellationToken cancellationToken = default) =>
         await service.ApproveDisbursementAsync(disbursementIdHash, userId, cancellationToken);
 
-    public async ValueTask<Result> CreateDisbursementAsync(CreateDisbursementRequest request, Guid userId, CancellationToken cancellationToken = default) =>
+    [Audit]
+    public async Task<Result> CreateDisbursementAsync(CreateDisbursementRequest request, Guid userId, CancellationToken cancellationToken = default) =>
         await service.CreateDisbursementAsync(request, userId, cancellationToken);
 
-    public async ValueTask<Result> CreateRiskAsync(CreateRiskRequest request, Guid userId, CancellationToken cancellationToken = default) =>
+    [Audit]
+    public async Task<Result> CreateRiskAsync(CreateRiskRequest request, Guid userId, CancellationToken cancellationToken = default) =>
         await service.CreateRiskAsync(request, userId, cancellationToken);
 
-    public async ValueTask<Result<Disbursement>> GetDisbursementAsync(string disbursementIdHash, CancellationToken cancellationToken = default) =>
-        await Result.Try((Func<ValueTask<Result<Disbursement>>>)(async () =>
+    public async Task<Result<Disbursement>> GetDisbursementAsync(string disbursementIdHash, CancellationToken cancellationToken = default) =>
+        await Result.Try((Func<Task<Result<Disbursement>>>)(async () =>
         {
             if (!await featureManager.IsEnabledAsync(ServiceCachingFeature))
                 return await service.GetDisbursementAsync(disbursementIdHash, cancellationToken);
@@ -44,8 +48,8 @@ public sealed class ExecutionCacheService(ExecutionService service, IDistributed
             return Result.Ok(cached.FromJson<Disbursement>());
         }));
 
-    public async ValueTask<Result<Disbursement[]>> GetDisbursementsAsync(Pagination pagination, CancellationToken cancellationToken = default) =>
-        await Result.Try((Func<ValueTask<Result<Disbursement[]>>>)(async () =>
+    public async Task<Result<Disbursement[]>> GetDisbursementsAsync(Pagination pagination, CancellationToken cancellationToken = default) =>
+        await Result.Try((Func<Task<Result<Disbursement[]>>>)(async () =>
         {
             if (!await featureManager.IsEnabledAsync(ServiceCachingFeature))
                 return await service.GetDisbursementsAsync(pagination, cancellationToken);
@@ -68,8 +72,8 @@ public sealed class ExecutionCacheService(ExecutionService service, IDistributed
             return Result.Ok(cached.FromJson<Disbursement[]>());
         }));
 
-    public async ValueTask<Result<Risk>> GetRiskAsync(string riskIdHash, CancellationToken cancellationToken = default) =>
-        await Result.Try((Func<ValueTask<Result<Risk>>>)(async () =>
+    public async Task<Result<Risk>> GetRiskAsync(string riskIdHash, CancellationToken cancellationToken = default) =>
+        await Result.Try((Func<Task<Result<Risk>>>)(async () =>
         {
             if (!await featureManager.IsEnabledAsync(ServiceCachingFeature))
                 return await service.GetRiskAsync(riskIdHash, cancellationToken);
@@ -92,8 +96,8 @@ public sealed class ExecutionCacheService(ExecutionService service, IDistributed
             return Result.Ok(cached.FromJson<Risk>());
         }));
 
-    public async ValueTask<Result<Risk[]>> GetRisksAsync(Pagination pagination, CancellationToken cancellationToken = default) =>
-        await Result.Try((Func<ValueTask<Result<Risk[]>>>)(async () =>
+    public async Task<Result<Risk[]>> GetRisksAsync(Pagination pagination, CancellationToken cancellationToken = default) =>
+        await Result.Try((Func<Task<Result<Risk[]>>>)(async () =>
         {
             if (!await featureManager.IsEnabledAsync(ServiceCachingFeature))
                 return await service.GetRisksAsync(pagination, cancellationToken);
@@ -116,9 +120,11 @@ public sealed class ExecutionCacheService(ExecutionService service, IDistributed
             return Result.Ok(cached.FromJson<Risk[]>());
         }));
 
-    public async ValueTask<Result> UpdateDisbursementAsync(UpdateDisbursementRequest request, Guid userId, CancellationToken cancellationToken = default) =>
+    [Audit]
+    public async Task<Result> UpdateDisbursementAsync(UpdateDisbursementRequest request, Guid userId, CancellationToken cancellationToken = default) =>
         await service.UpdateDisbursementAsync(request, userId, cancellationToken);
 
-    public async ValueTask<Result> UpdateRiskAsync(UpdateRiskRequest request, CancellationToken cancellationToken = default) =>
+    [Audit]
+    public async Task<Result> UpdateRiskAsync(UpdateRiskRequest request, CancellationToken cancellationToken = default) =>
         await service.UpdateRiskAsync(request, cancellationToken);
 }

PostFundManagement.Application/Services/Execution/ExecutionService.cs

@@ -10,8 +10,8 @@ namespace PostFundManagement.Application.Services.Execution;
 
 public sealed class ExecutionService(IDbContextFactory<ApplicationDbContext> contextFactory, HashService hashService) : IExecutionService
 {
-    public async ValueTask<Result<Risk[]>> GetRisksAsync(Pagination pagination, CancellationToken cancellationToken = default) =>
-        await Result.Try((Func<ValueTask<Result<Risk[]>>>)(async () =>
+    public async Task<Result<Risk[]>> GetRisksAsync(Pagination pagination, CancellationToken cancellationToken = default) =>
+        await Result.Try((Func<Task<Result<Risk[]>>>)(async () =>
         {
             await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
 
@@ -24,8 +24,8 @@ public sealed class ExecutionService(IDbContextFactory<ApplicationDbContext> con
             return Result.Ok(risks.Select(i => i.Map()).ToArray());
         }));
 
-    public async ValueTask<Result<Disbursement[]>> GetDisbursementsAsync(Pagination pagination, CancellationToken cancellationToken = default) =>
-        await Result.Try((Func<ValueTask<Result<Disbursement[]>>>)(async () =>
+    public async Task<Result<Disbursement[]>> GetDisbursementsAsync(Pagination pagination, CancellationToken cancellationToken = default) =>
+        await Result.Try((Func<Task<Result<Disbursement[]>>>)(async () =>
         {
             await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
 
@@ -38,8 +38,8 @@ public sealed class ExecutionService(IDbContextFactory<ApplicationDbContext> con
             return Result.Ok(disbursements.Select(i => i.Map()).ToArray());
         }));
     
-    public async ValueTask<Result> CreateRiskAsync(CreateRiskRequest request, Guid userId, CancellationToken cancellationToken = default) =>
-        await Result.Try((Func<ValueTask<Result>>)(async () =>
+    public async Task<Result> CreateRiskAsync(CreateRiskRequest request, Guid userId, CancellationToken cancellationToken = default) =>
+        await Result.Try((Func<Task<Result>>)(async () =>
         {
             await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
 
@@ -60,8 +60,8 @@ public sealed class ExecutionService(IDbContextFactory<ApplicationDbContext> con
             return Result.OkIf(await context.SaveChangesAsync(cancellationToken) > 0, CreateError.New);
         }));
 
-    public async ValueTask<Result> CreateDisbursementAsync(CreateDisbursementRequest request, Guid userId, CancellationToken cancellationToken = default) =>
-        await Result.Try((Func<ValueTask<Result>>)(async () =>
+    public async Task<Result> CreateDisbursementAsync(CreateDisbursementRequest request, Guid userId, CancellationToken cancellationToken = default) =>
+        await Result.Try((Func<Task<Result>>)(async () =>
         {
             await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
 
@@ -81,8 +81,8 @@ public sealed class ExecutionService(IDbContextFactory<ApplicationDbContext> con
             return Result.OkIf(await context.SaveChangesAsync(cancellationToken) > 0, CreateError.New);
         }));
 
-    public async ValueTask<Result> ApproveDisbursementAsync(string disbursementIdHash, Guid userId, CancellationToken cancellationToken = default) =>
-        await Result.Try((Func<ValueTask<Result>>)(async () =>
+    public async Task<Result> ApproveDisbursementAsync(string disbursementIdHash, Guid userId, CancellationToken cancellationToken = default) =>
+        await Result.Try((Func<Task<Result>>)(async () =>
         {
             var decodeResult = hashService.DecodeLongIdHash(disbursementIdHash);
 
@@ -101,8 +101,8 @@ public sealed class ExecutionService(IDbContextFactory<ApplicationDbContext> con
             return Result.OkIf(changedTotal > 0, UpdateError.New);
         }));
 
-    public async ValueTask<Result<Disbursement>> GetDisbursementAsync(string disbursementIdHash, CancellationToken cancellationToken) =>
-        await Result.Try((Func<ValueTask<Result<Disbursement>>>)(async () =>
+    public async Task<Result<Disbursement>> GetDisbursementAsync(string disbursementIdHash, CancellationToken cancellationToken) =>
+        await Result.Try((Func<Task<Result<Disbursement>>>)(async () =>
         {
             var decodeResult = hashService.DecodeLongIdHash(disbursementIdHash);
 
@@ -119,8 +119,8 @@ public sealed class ExecutionService(IDbContextFactory<ApplicationDbContext> con
                 .ToResult(disbursement!.Map());
         }));
 
-    public async ValueTask<Result<Risk>> GetRiskAsync(string riskIdHash, CancellationToken cancellationToken = default) =>
-        await Result.Try((Func<ValueTask<Result<Risk>>>)(async () =>
+    public async Task<Result<Risk>> GetRiskAsync(string riskIdHash, CancellationToken cancellationToken = default) =>
+        await Result.Try((Func<Task<Result<Risk>>>)(async () =>
         {
             var decodeResult = hashService.DecodeLongIdHash(riskIdHash);
 
@@ -137,8 +137,8 @@ public sealed class ExecutionService(IDbContextFactory<ApplicationDbContext> con
                 .ToResult(risk!.Map());
         }));
 
-    public async ValueTask<Result> UpdateRiskAsync(UpdateRiskRequest request, CancellationToken cancellationToken = default) =>
-        await Result.Try((Func<ValueTask<Result>>)(async () =>
+    public async Task<Result> UpdateRiskAsync(UpdateRiskRequest request, CancellationToken cancellationToken = default) =>
+        await Result.Try((Func<Task<Result>>)(async () =>
         {
             await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
 
@@ -153,8 +153,8 @@ public sealed class ExecutionService(IDbContextFactory<ApplicationDbContext> con
             return Result.OkIf(changedTotal > 0, UpdateError.New);
         }));
 
-    public async ValueTask<Result> UpdateDisbursementAsync(UpdateDisbursementRequest request, Guid userId, CancellationToken cancellationToken = default) =>
-        await Result.Try((Func<ValueTask<Result>>)(async () =>
+    public async Task<Result> UpdateDisbursementAsync(UpdateDisbursementRequest request, Guid userId, CancellationToken cancellationToken = default) =>
+        await Result.Try((Func<Task<Result>>)(async () =>
         {
             await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
 

PostFundManagement.Application/Services/Governance/GovernanceCacheService.cs

@@ -3,6 +3,7 @@ using PostFundManagement.Application.Abstractions.Services;
 using PostFundManagement.Application.Extensions;
 using PostFundManagement.Application.Services.Shared;
 using PostFundManagement.Domain;
+using PostFundManagement.Domain.Attributes;
 using PostFundManagement.Domain.Models;
 using static PostFundManagement.Domain.Extensions.Constants;
 
@@ -11,14 +12,16 @@ namespace PostFundManagement.Application.Services.Governance;
 public sealed class GovernanceCacheService(GovernanceService service, IDistributedCache cache,
     IFeatureManager featureManager) : ServiceCacheBase, IGovernanceService
 {
-    public async ValueTask<Result> CreateOrganisationAsync(CreateOrganisationRequest request, Guid userId, CancellationToken cancellationToken = default) =>
+    [Audit]
+    public async Task<Result> CreateOrganisationAsync(CreateOrganisationRequest request, Guid userId, CancellationToken cancellationToken = default) =>
         await service.CreateOrganisationAsync(request, userId, cancellationToken);
 
-    public async ValueTask<Result> CreatePortfolioAsync(CreatePortfolioRequest request, Guid userId, CancellationToken cancellationToken = default) =>
+    [Audit]
+    public async Task<Result> CreatePortfolioAsync(CreatePortfolioRequest request, Guid userId, CancellationToken cancellationToken = default) =>
         await service.CreatePortfolioAsync(request, userId, cancellationToken);
 
-    public async ValueTask<Result<Dashboard>> GetDashboardAsync(CancellationToken cancellationToken = default) =>
-        await Result.Try((Func<ValueTask<Result<Dashboard>>>)(async () =>
+    public async Task<Result<Dashboard>> GetDashboardAsync(CancellationToken cancellationToken = default) =>
+        await Result.Try((Func<Task<Result<Dashboard>>>)(async () =>
         {
             if (!await featureManager.IsEnabledAsync(ServiceCachingFeature))
                 return await service.GetDashboardAsync(cancellationToken);
@@ -41,8 +44,8 @@ public sealed class GovernanceCacheService(GovernanceService service, IDistribut
             return Result.Ok(cached.FromJson<Dashboard>());
         }));
 
-    public async ValueTask<Result<Instrument[]>> GetInstrumentsAsync(string programmeIdHash, CancellationToken cancellationToken = default) =>
-        await Result.Try((Func<ValueTask<Result<Instrument[]>>>)(async () =>
+    public async Task<Result<Instrument[]>> GetInstrumentsAsync(string programmeIdHash, CancellationToken cancellationToken = default) =>
+        await Result.Try((Func<Task<Result<Instrument[]>>>)(async () =>
         {
             if (!await featureManager.IsEnabledAsync(ServiceCachingFeature))
                 return await service.GetInstrumentsAsync(programmeIdHash, cancellationToken);
@@ -65,8 +68,8 @@ public sealed class GovernanceCacheService(GovernanceService service, IDistribut
             return Result.Ok(cached.FromJson<Instrument[]>());
         }));
 
-    public async ValueTask<Result<Organisation>> GetOrganisationAsync(string organisationIdHash, CancellationToken cancellationToken = default) =>
-        await Result.Try((Func<ValueTask<Result<Organisation>>>)(async () =>
+    public async Task<Result<Organisation>> GetOrganisationAsync(string organisationIdHash, CancellationToken cancellationToken = default) =>
+        await Result.Try((Func<Task<Result<Organisation>>>)(async () =>
         {
             if (!await featureManager.IsEnabledAsync(ServiceCachingFeature))
                 return await service.GetOrganisationAsync(organisationIdHash, cancellationToken);
@@ -89,8 +92,8 @@ public sealed class GovernanceCacheService(GovernanceService service, IDistribut
             return Result.Ok(cached.FromJson<Organisation>());
         }));
 
-    public async ValueTask<Result<Organisation[]>> GetOrganisationsAsync(Pagination pagination, CancellationToken cancellationToken = default) =>
-        await Result.Try((Func<ValueTask<Result<Organisation[]>>>)(async () =>
+    public async Task<Result<Organisation[]>> GetOrganisationsAsync(Pagination pagination, CancellationToken cancellationToken = default) =>
+        await Result.Try((Func<Task<Result<Organisation[]>>>)(async () =>
         {
             if (!await featureManager.IsEnabledAsync(ServiceCachingFeature))
                 return await service.GetOrganisationsAsync(pagination, cancellationToken);
@@ -113,8 +116,8 @@ public sealed class GovernanceCacheService(GovernanceService service, IDistribut
             return Result.Ok(cached.FromJson<Organisation[]>());
         }));
 
-    public async ValueTask<Result<Portfolio[]>> GetPorfoliosAsync(string organisationIdHash, CancellationToken cancellationToken = default) =>
-        await Result.Try((Func<ValueTask<Result<Portfolio[]>>>)(async () =>
+    public async Task<Result<Portfolio[]>> GetPorfoliosAsync(string organisationIdHash, CancellationToken cancellationToken = default) =>
+        await Result.Try((Func<Task<Result<Portfolio[]>>>)(async () =>
         {
             if (!await featureManager.IsEnabledAsync(ServiceCachingFeature))
                 return await service.GetPorfoliosAsync(organisationIdHash, cancellationToken);
@@ -137,8 +140,8 @@ public sealed class GovernanceCacheService(GovernanceService service, IDistribut
             return Result.Ok(cached.FromJson<Portfolio[]>());
         }));
 
-    public async ValueTask<Result<Portfolio>> GetPortfolioAsync(string portfolioIdHash, CancellationToken cancellationToken = default) =>
-        await Result.Try((Func<ValueTask<Result<Portfolio>>>)(async () =>
+    public async Task<Result<Portfolio>> GetPortfolioAsync(string portfolioIdHash, CancellationToken cancellationToken = default) =>
+        await Result.Try((Func<Task<Result<Portfolio>>>)(async () =>
         {
             if (!await featureManager.IsEnabledAsync(ServiceCachingFeature))
                 return await service.GetPortfolioAsync(portfolioIdHash, cancellationToken);
@@ -161,8 +164,8 @@ public sealed class GovernanceCacheService(GovernanceService service, IDistribut
             return Result.Ok(cached.FromJson<Portfolio>());
         }));
 
-    public async ValueTask<Result<Programme[]>> GetPortfolioProgrammesAsync(string portfolioIdHash, CancellationToken cancellationToken = default) =>
-        await Result.Try((Func<ValueTask<Result<Programme[]>>>)(async () =>
+    public async Task<Result<Programme[]>> GetPortfolioProgrammesAsync(string portfolioIdHash, CancellationToken cancellationToken = default) =>
+        await Result.Try((Func<Task<Result<Programme[]>>>)(async () =>
         {
             if (!await featureManager.IsEnabledAsync(ServiceCachingFeature))
                 return await service.GetPortfolioProgrammesAsync(portfolioIdHash, cancellationToken);
@@ -185,8 +188,8 @@ public sealed class GovernanceCacheService(GovernanceService service, IDistribut
             return Result.Ok(cached.FromJson<Programme[]>());
         }));
 
-    public async ValueTask<Result<Programme[]>> GetProgrammesAsync(string portfolioIdHash, CancellationToken cancellationToken = default) =>
-        await Result.Try((Func<ValueTask<Result<Programme[]>>>)(async () =>
+    public async Task<Result<Programme[]>> GetProgrammesAsync(string portfolioIdHash, CancellationToken cancellationToken = default) =>
+        await Result.Try((Func<Task<Result<Programme[]>>>)(async () =>
         {
             if (!await featureManager.IsEnabledAsync(ServiceCachingFeature))
                 return await service.GetProgrammesAsync(portfolioIdHash, cancellationToken);
@@ -209,9 +212,11 @@ public sealed class GovernanceCacheService(GovernanceService service, IDistribut
             return Result.Ok(cached.FromJson<Programme[]>());
         }));
 
-    public async ValueTask<Result<Organisation>> UpdateOrganisationAsync(UpdateOrganisationRequest request, CancellationToken cancellationToken = default) =>
+    [Audit]
+    public async Task<Result<Organisation>> UpdateOrganisationAsync(UpdateOrganisationRequest request, CancellationToken cancellationToken = default) =>
         await service.UpdateOrganisationAsync(request, cancellationToken);
 
-    public async ValueTask<Result> UpdatePortfolioAsync(UpdatePortfolioRequest request, Guid userId, CancellationToken cancellationToken = default) =>
+    [Audit]
+    public async Task<Result> UpdatePortfolioAsync(UpdatePortfolioRequest request, Guid userId, CancellationToken cancellationToken = default) =>
         await service.UpdatePortfolioAsync(request, userId, cancellationToken);
 }

PostFundManagement.Application/Services/Governance/GovernanceService.cs

@@ -1,18 +1,18 @@
 using PostFundManagement.Application.Abstractions.Services;
+using PostFundManagement.Application.Extensions;
 using PostFundManagement.Application.Services.Shared;
 using PostFundManagement.Domain;
 using PostFundManagement.Domain.Errors;
 using PostFundManagement.Domain.Extensions;
 using PostFundManagement.Domain.Models;
 using PostFundManagement.Infrastructure.Database;
-using PostFundManagement.Application.Extensions;
 
 namespace PostFundManagement.Application.Services.Governance;
 
 public sealed class GovernanceService(IDbContextFactory<ApplicationDbContext> contextFactory, HashService hashService) : IGovernanceService
 {
-    public async ValueTask<Result<Programme[]>> GetProgrammesAsync(string portfolioIdHash, CancellationToken cancellationToken = default) =>
-        await Result.Try((Func<ValueTask<Result<Programme[]>>>)(async () =>
+    public async Task<Result<Programme[]>> GetProgrammesAsync(string portfolioIdHash, CancellationToken cancellationToken = default) =>
+        await Result.Try((Func<Task<Result<Programme[]>>>)(async () =>
         {
             var decodeResult = hashService.DecodeLongIdHash(portfolioIdHash);
 
@@ -30,8 +30,8 @@ public sealed class GovernanceService(IDbContextFactory<ApplicationDbContext> co
             return Result.Ok(programmes.Select(p => p.Map()).ToArray());
         }));
 
-    public async ValueTask<Result<Portfolio[]>> GetPorfoliosAsync(string organisationIdHash, CancellationToken cancellationToken = default) =>
-        await Result.Try((Func<ValueTask<Result<Portfolio[]>>>)(async () =>
+    public async Task<Result<Portfolio[]>> GetPorfoliosAsync(string organisationIdHash, CancellationToken cancellationToken = default) =>
+        await Result.Try((Func<Task<Result<Portfolio[]>>>)(async () =>
         {
             var decodeResult = hashService.DecodeLongIdHash(organisationIdHash);
 
@@ -49,8 +49,8 @@ public sealed class GovernanceService(IDbContextFactory<ApplicationDbContext> co
             return Result.Ok(portfolios.Select(p => p.Map()).ToArray());
         }));
 
-    public async ValueTask<Result<Organisation[]>> GetOrganisationsAsync(Pagination pagination, CancellationToken cancellationToken = default) =>
-        await Result.Try((Func<ValueTask<Result<Organisation[]>>>)(async () =>
+    public async Task<Result<Organisation[]>> GetOrganisationsAsync(Pagination pagination, CancellationToken cancellationToken = default) =>
+        await Result.Try((Func<Task<Result<Organisation[]>>>)(async () =>
         {
             await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
 
@@ -63,8 +63,8 @@ public sealed class GovernanceService(IDbContextFactory<ApplicationDbContext> co
             return Result.Ok(organisations.Select(o => o.Map()).ToArray());
         }));
 
-    public async ValueTask<Result<Organisation>> GetOrganisationAsync(string organisationIdHash, CancellationToken cancellationToken = default) =>
-        await Result.Try((Func<ValueTask<Result<Organisation>>>)(async () =>
+    public async Task<Result<Organisation>> GetOrganisationAsync(string organisationIdHash, CancellationToken cancellationToken = default) =>
+        await Result.Try((Func<Task<Result<Organisation>>>)(async () =>
         {
             var decodeResult = hashService.DecodeLongIdHash(organisationIdHash);
 
@@ -81,8 +81,8 @@ public sealed class GovernanceService(IDbContextFactory<ApplicationDbContext> co
                 .ToResult(organisation!.Map());
         }));
 
-    public async ValueTask<Result<Instrument[]>> GetInstrumentsAsync(string programmeIdHash, CancellationToken cancellationToken = default) =>
-        await Result.Try((Func<ValueTask<Result<Instrument[]>>>)(async () =>
+    public async Task<Result<Instrument[]>> GetInstrumentsAsync(string programmeIdHash, CancellationToken cancellationToken = default) =>
+        await Result.Try((Func<Task<Result<Instrument[]>>>)(async () =>
         {
             var decodeResult = hashService.DecodeLongIdHash(programmeIdHash);
 
@@ -100,8 +100,8 @@ public sealed class GovernanceService(IDbContextFactory<ApplicationDbContext> co
             return Result.Ok(instruments.Select(i => i.Map()).ToArray());
         }));
 
-    public async ValueTask<Result<Dashboard>> GetDashboardAsync(CancellationToken cancellationToken = default) =>
-        await Result.Try((Func<ValueTask<Result<Dashboard>>>)(async () =>
+    public async Task<Result<Dashboard>> GetDashboardAsync(CancellationToken cancellationToken = default) =>
+        await Result.Try((Func<Task<Result<Dashboard>>>)(async () =>
         {
             await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
 
@@ -126,8 +126,8 @@ public sealed class GovernanceService(IDbContextFactory<ApplicationDbContext> co
                 disbursedAmount, onTrackPercentage, atRiskCount, beneficiariesReached));
         }));
 
-    public async ValueTask<Result> CreateOrganisationAsync(CreateOrganisationRequest request, Guid userId, CancellationToken cancellationToken = default) =>
-        await Result.Try((Func<ValueTask<Result>>)(async () =>
+    public async Task<Result> CreateOrganisationAsync(CreateOrganisationRequest request, Guid userId, CancellationToken cancellationToken = default) =>
+        await Result.Try((Func<Task<Result>>)(async () =>
         {
             await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
 
@@ -150,8 +150,8 @@ public sealed class GovernanceService(IDbContextFactory<ApplicationDbContext> co
             return Result.OkIf(await context.SaveChangesAsync(cancellationToken) > 0, CreateError.New);
         }));
 
-    public async ValueTask<Result<Organisation>> UpdateOrganisationAsync(UpdateOrganisationRequest request, CancellationToken cancellationToken = default) =>
-        await Result.Try((Func<ValueTask<Result<Organisation>>>)(async () =>
+    public async Task<Result<Organisation>> UpdateOrganisationAsync(UpdateOrganisationRequest request, CancellationToken cancellationToken = default) =>
+        await Result.Try((Func<Task<Result<Organisation>>>)(async () =>
         {
             await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
 
@@ -166,8 +166,8 @@ public sealed class GovernanceService(IDbContextFactory<ApplicationDbContext> co
             return Result.OkIf(changedTotal > 0, UpdateError.New);
         }));
 
-    public async ValueTask<Result> CreatePortfolioAsync(CreatePortfolioRequest request, Guid userId, CancellationToken cancellationToken = default) =>
-        await Result.Try((Func<ValueTask<Result>>)(async () =>
+    public async Task<Result> CreatePortfolioAsync(CreatePortfolioRequest request, Guid userId, CancellationToken cancellationToken = default) =>
+        await Result.Try((Func<Task<Result>>)(async () =>
         {
             await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
 
@@ -195,8 +195,8 @@ public sealed class GovernanceService(IDbContextFactory<ApplicationDbContext> co
             return Result.OkIf(await context.SaveChangesAsync(cancellationToken) > 0, CreateError.New);
         }));
 
-    public async ValueTask<Result> UpdatePortfolioAsync(UpdatePortfolioRequest request, Guid userId, CancellationToken cancellationToken = default) =>
-        await Result.Try((Func<ValueTask<Result>>)(async () =>
+    public async Task<Result> UpdatePortfolioAsync(UpdatePortfolioRequest request, Guid userId, CancellationToken cancellationToken = default) =>
+        await Result.Try((Func<Task<Result>>)(async () =>
         {
             await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
 
@@ -213,8 +213,8 @@ public sealed class GovernanceService(IDbContextFactory<ApplicationDbContext> co
             return Result.OkIf(changedTotal > 0, UpdateError.Create("Nothing was saved, no change detected."));
         }));
 
-    public async ValueTask<Result<Programme[]>> GetPortfolioProgrammesAsync(string portfolioIdHash, CancellationToken cancellationToken = default) =>
-        await Result.Try((Func<ValueTask<Result<Programme[]>>>)(async () =>
+    public async Task<Result<Programme[]>> GetPortfolioProgrammesAsync(string portfolioIdHash, CancellationToken cancellationToken = default) =>
+        await Result.Try((Func<Task<Result<Programme[]>>>)(async () =>
         {
             var decodeResult = hashService.DecodeLongIdHash(portfolioIdHash);
 
@@ -232,8 +232,8 @@ public sealed class GovernanceService(IDbContextFactory<ApplicationDbContext> co
             return Result.Ok(programmes.Select(p => p.Map()).ToArray());
         }));
 
-    public async ValueTask<Result<Portfolio>> GetPortfolioAsync(string portfolioIdHash, CancellationToken cancellationToken = default) =>
-        await Result.Try((Func<ValueTask<Result<Portfolio>>>)(async () =>
+    public async Task<Result<Portfolio>> GetPortfolioAsync(string portfolioIdHash, CancellationToken cancellationToken = default) =>
+        await Result.Try((Func<Task<Result<Portfolio>>>)(async () =>
         {
             var decodeResult = hashService.DecodeLongIdHash(portfolioIdHash);
 

PostFundManagement.Application/Services/Grants/GrantsCacheService.cs

@@ -3,6 +3,7 @@ using PostFundManagement.Application.Abstractions.Services;
 using PostFundManagement.Application.Extensions;
 using PostFundManagement.Application.Services.Shared;
 using PostFundManagement.Domain;
+using PostFundManagement.Domain.Attributes;
 using PostFundManagement.Domain.Models;
 using static PostFundManagement.Domain.Extensions.Constants;
 
@@ -11,20 +12,24 @@ namespace PostFundManagement.Application.Services.Grants;
 public sealed class GrantsCacheService(GrantsService service, IDistributedCache cache,
     IFeatureManager featureManager) : ServiceCacheBase, IGrantsService
 {
-    public async ValueTask<Result> CreateAwardAsync(CreateAwardRequest request, Guid userId, CancellationToken cancellationToken = default) =>
+    [Audit]
+    public async Task<Result> CreateAwardAsync(CreateAwardRequest request, Guid userId, CancellationToken cancellationToken = default) =>
         await service.CreateAwardAsync(request, userId, cancellationToken);
 
-    public async ValueTask<Result> CreateBudgetAsync(CreateBudgetRequest request, Guid userId, CancellationToken cancellationToken = default) =>
+    [Audit]
+    public async Task<Result> CreateBudgetAsync(CreateBudgetRequest request, Guid userId, CancellationToken cancellationToken = default) =>
         await service.CreateBudgetAsync(request, userId, cancellationToken);
 
-    public async ValueTask<Result> CreateContractAsync(CreateContractRequest request, Guid userId, CancellationToken cancellationToken = default) =>
+    [Audit]
+    public async Task<Result> CreateContractAsync(CreateContractRequest request, Guid userId, CancellationToken cancellationToken = default) =>
         await service.CreateContractAsync(request, userId, cancellationToken);
 
-    public async ValueTask<Result> ExecuteContractAsync(ExecuteContractRequest request, Guid userId, CancellationToken cancellationToken = default) =>
+    [Audit]
+    public async Task<Result> ExecuteContractAsync(ExecuteContractRequest request, Guid userId, CancellationToken cancellationToken = default) =>
         await service.ExecuteContractAsync(request, userId, cancellationToken);
 
-    public async ValueTask<Result<Award>> GetAwardAsync(string awardIdHash, CancellationToken cancellationToken = default) =>
-        await Result.Try((Func<ValueTask<Result<Award>>>)(async () =>
+    public async Task<Result<Award>> GetAwardAsync(string awardIdHash, CancellationToken cancellationToken = default) =>
+        await Result.Try((Func<Task<Result<Award>>>)(async () =>
         {
             if (!await featureManager.IsEnabledAsync(ServiceCachingFeature))
                 return await service.GetAwardAsync(awardIdHash, cancellationToken);
@@ -47,8 +52,8 @@ public sealed class GrantsCacheService(GrantsService service, IDistributedCache
             return Result.Ok(cached.FromJson<Award>());
         }));
 
-    public async ValueTask<Result<Award[]>> GetAwardsAsync(Pagination pagination, CancellationToken cancellationToken = default) =>
-        await Result.Try((Func<ValueTask<Result<Award[]>>>)(async () =>
+    public async Task<Result<Award[]>> GetAwardsAsync(Pagination pagination, CancellationToken cancellationToken = default) =>
+        await Result.Try((Func<Task<Result<Award[]>>>)(async () =>
         {
             if (!await featureManager.IsEnabledAsync(ServiceCachingFeature))
                 return await service.GetAwardsAsync(pagination, cancellationToken);
@@ -71,8 +76,8 @@ public sealed class GrantsCacheService(GrantsService service, IDistributedCache
             return Result.Ok(cached.FromJson<Award[]>());
         }));
 
-    public async ValueTask<Result<Budget>> GetBudgetAsync(string budgetIdHash, CancellationToken cancellationToken = default) =>
-        await Result.Try((Func<ValueTask<Result<Budget>>>)(async () =>
+    public async Task<Result<Budget>> GetBudgetAsync(string budgetIdHash, CancellationToken cancellationToken = default) =>
+        await Result.Try((Func<Task<Result<Budget>>>)(async () =>
         {
             if (!await featureManager.IsEnabledAsync(ServiceCachingFeature))
                 return await service.GetBudgetAsync(budgetIdHash, cancellationToken);
@@ -95,8 +100,8 @@ public sealed class GrantsCacheService(GrantsService service, IDistributedCache
             return Result.Ok(cached.FromJson<Budget>());
         }));
 
-    public async ValueTask<Result<Budget[]>> GetBudgetsAsync(Pagination pagination, CancellationToken cancellationToken = default) =>
-        await Result.Try((Func<ValueTask<Result<Budget[]>>>)(async () =>
+    public async Task<Result<Budget[]>> GetBudgetsAsync(Pagination pagination, CancellationToken cancellationToken = default) =>
+        await Result.Try((Func<Task<Result<Budget[]>>>)(async () =>
         {
             if (!await featureManager.IsEnabledAsync(ServiceCachingFeature))
                 return await service.GetBudgetsAsync(pagination, cancellationToken);
@@ -119,8 +124,8 @@ public sealed class GrantsCacheService(GrantsService service, IDistributedCache
             return Result.Ok(cached.FromJson<Budget[]>());
         }));
 
-    public async ValueTask<Result<Contract>> GetContractAsync(string contractIdHash, CancellationToken cancellationToken = default) =>
-        await Result.Try((Func<ValueTask<Result<Contract>>>)(async () =>
+    public async Task<Result<Contract>> GetContractAsync(string contractIdHash, CancellationToken cancellationToken = default) =>
+        await Result.Try((Func<Task<Result<Contract>>>)(async () =>
         {
             if (!await featureManager.IsEnabledAsync(ServiceCachingFeature))
                 return await service.GetContractAsync(contractIdHash, cancellationToken);
@@ -143,8 +148,8 @@ public sealed class GrantsCacheService(GrantsService service, IDistributedCache
             return Result.Ok(cached.FromJson<Contract>());
         }));
 
-    public async ValueTask<Result<Contract[]>> GetContractsAsync(Pagination pagination, CancellationToken cancellationToken = default) =>
-        await Result.Try((Func<ValueTask<Result<Contract[]>>>)(async () =>
+    public async Task<Result<Contract[]>> GetContractsAsync(Pagination pagination, CancellationToken cancellationToken = default) =>
+        await Result.Try((Func<Task<Result<Contract[]>>>)(async () =>
         {
             if (!await featureManager.IsEnabledAsync(ServiceCachingFeature))
                 return await service.GetContractsAsync(pagination, cancellationToken);
@@ -167,8 +172,8 @@ public sealed class GrantsCacheService(GrantsService service, IDistributedCache
             return Result.Ok(cached.FromJson<Contract[]>());
         }));
 
-    public async ValueTask<Result<string>> GetContractUrlAsync(string contractIdHash, CancellationToken cancellationToken = default) =>
-        await Result.Try((Func<ValueTask<Result<string>>>)(async () =>
+    public async Task<Result<string>> GetContractUrlAsync(string contractIdHash, CancellationToken cancellationToken = default) =>
+        await Result.Try((Func<Task<Result<string>>>)(async () =>
         {
             if (!await featureManager.IsEnabledAsync(ServiceCachingFeature))
                 return await service.GetContractUrlAsync(contractIdHash, cancellationToken);
@@ -191,9 +196,11 @@ public sealed class GrantsCacheService(GrantsService service, IDistributedCache
             return Result.Ok(cached!);
         }));
 
-    public async ValueTask<Result> UpdateContractAsync(UpdateContractRequest request, CancellationToken cancellationToken = default) =>
+    [Audit]
+    public async Task<Result> UpdateContractAsync(UpdateContractRequest request, CancellationToken cancellationToken = default) =>
         await service.UpdateContractAsync(request, cancellationToken);
 
-    public async ValueTask<Result> UploadContractAsync(string contractIdHash, Guid userId, IFormFile file, CancellationToken cancellationToken = default) =>
+    [Audit]
+    public async Task<Result> UploadContractAsync(string contractIdHash, Guid userId, IFormFile file, CancellationToken cancellationToken = default) =>
         await service.UploadContractAsync(contractIdHash, userId, file, cancellationToken);
 }

PostFundManagement.Application/Services/Grants/GrantsService.cs

@@ -12,8 +12,8 @@ namespace PostFundManagement.Application.Services.Grants;
 public sealed class GrantsService(IDbContextFactory<ApplicationDbContext> contextFactory, HashService hashService,
     [FromKeyedServices(Constants.GeneralBucketName)] IS3Service s3Service) : IGrantsService
 {
-    public async ValueTask<Result<Contract[]>> GetContractsAsync(Pagination pagination, CancellationToken cancellationToken = default) =>
-        await Result.Try((Func<ValueTask<Result<Contract[]>>>)(async () =>
+    public async Task<Result<Contract[]>> GetContractsAsync(Pagination pagination, CancellationToken cancellationToken = default) =>
+        await Result.Try((Func<Task<Result<Contract[]>>>)(async () =>
         {
             await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
 
@@ -26,8 +26,8 @@ public sealed class GrantsService(IDbContextFactory<ApplicationDbContext> contex
             return Result.Ok(contracts.Select(c => c.Map()).ToArray());
         }));
 
-    public async ValueTask<Result<Contract>> GetContractAsync(string contractIdHash, CancellationToken cancellationToken = default) =>
-        await Result.Try((Func<ValueTask<Result<Contract>>>)(async () =>
+    public async Task<Result<Contract>> GetContractAsync(string contractIdHash, CancellationToken cancellationToken = default) =>
+        await Result.Try((Func<Task<Result<Contract>>>)(async () =>
         {
             var decodeResult = hashService.DecodeLongIdHash(contractIdHash);
 
@@ -44,8 +44,8 @@ public sealed class GrantsService(IDbContextFactory<ApplicationDbContext> contex
                 .ToResult(contract!.Map());
         }));
 
-    public async ValueTask<Result<Budget[]>> GetBudgetsAsync(Pagination pagination, CancellationToken cancellationToken = default) =>
-        await Result.Try((Func<ValueTask<Result<Budget[]>>>)(async () =>
+    public async Task<Result<Budget[]>> GetBudgetsAsync(Pagination pagination, CancellationToken cancellationToken = default) =>
+        await Result.Try((Func<Task<Result<Budget[]>>>)(async () =>
         {
             await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
 
@@ -58,8 +58,8 @@ public sealed class GrantsService(IDbContextFactory<ApplicationDbContext> contex
             return Result.Ok(budgets.Select(b => b.Map()).ToArray());
         }));
 
-    public async ValueTask<Result<Budget>> GetBudgetAsync(string budgetIdHash, CancellationToken cancellationToken = default) =>
-        await Result.Try((Func<ValueTask<Result<Budget>>>)(async () =>
+    public async Task<Result<Budget>> GetBudgetAsync(string budgetIdHash, CancellationToken cancellationToken = default) =>
+        await Result.Try((Func<Task<Result<Budget>>>)(async () =>
         {
             var decodeResult = hashService.DecodeLongIdHash(budgetIdHash);
 
@@ -76,8 +76,8 @@ public sealed class GrantsService(IDbContextFactory<ApplicationDbContext> contex
                 .ToResult(budget!.Map());
         }));
 
-    public async ValueTask<Result<Award[]>> GetAwardsAsync(Pagination pagination, CancellationToken cancellationToken = default) =>
-        await Result.Try((Func<ValueTask<Result<Award[]>>>)(async () =>
+    public async Task<Result<Award[]>> GetAwardsAsync(Pagination pagination, CancellationToken cancellationToken = default) =>
+        await Result.Try((Func<Task<Result<Award[]>>>)(async () =>
         {
             await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
 
@@ -90,8 +90,8 @@ public sealed class GrantsService(IDbContextFactory<ApplicationDbContext> contex
             return Result.Ok(awards.Select(a => a.Map()).ToArray());
         }));
 
-    public async ValueTask<Result<Award>> GetAwardAsync(string awardIdHash, CancellationToken cancellationToken = default) =>
-        await Result.Try((Func<ValueTask<Result<Award>>>)(async () =>
+    public async Task<Result<Award>> GetAwardAsync(string awardIdHash, CancellationToken cancellationToken = default) =>
+        await Result.Try((Func<Task<Result<Award>>>)(async () =>
         {
             var decodeResult = hashService.DecodeLongIdHash(awardIdHash);
 
@@ -107,8 +107,8 @@ public sealed class GrantsService(IDbContextFactory<ApplicationDbContext> contex
                 .ToResult(award!.Map());
         }));
 
-    public async ValueTask<Result> ExecuteContractAsync(ExecuteContractRequest request, Guid userId, CancellationToken cancellationToken = default) =>
-        await Result.Try((Func<ValueTask<Result>>)(async () =>
+    public async Task<Result> ExecuteContractAsync(ExecuteContractRequest request, Guid userId, CancellationToken cancellationToken = default) =>
+        await Result.Try((Func<Task<Result>>)(async () =>
         {
             await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
 
@@ -123,8 +123,8 @@ public sealed class GrantsService(IDbContextFactory<ApplicationDbContext> contex
             return Result.OkIf(await context.SaveChangesAsync(cancellationToken) > 0, UpdateError.New);
         }));
 
-    public async ValueTask<Result> CreateContractAsync(CreateContractRequest request, Guid userId, CancellationToken cancellationToken = default) =>
-        await Result.Try((Func<ValueTask<Result>>)(async () =>
+    public async Task<Result> CreateContractAsync(CreateContractRequest request, Guid userId, CancellationToken cancellationToken = default) =>
+        await Result.Try((Func<Task<Result>>)(async () =>
         {
             await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
 
@@ -150,8 +150,8 @@ public sealed class GrantsService(IDbContextFactory<ApplicationDbContext> contex
             return Result.OkIf(await context.SaveChangesAsync(cancellationToken) > 0, CreateError.New);
         }));
 
-    public async ValueTask<Result> CreateBudgetAsync(CreateBudgetRequest request, Guid userId, CancellationToken cancellationToken = default) =>
-        await Result.Try((Func<ValueTask<Result>>)(async () =>
+    public async Task<Result> CreateBudgetAsync(CreateBudgetRequest request, Guid userId, CancellationToken cancellationToken = default) =>
+        await Result.Try((Func<Task<Result>>)(async () =>
         {
             if (request.Amount <= 0)
                 return Result.Fail(ValidationError.Create("Budget amount must be greater than zero."));
@@ -175,8 +175,8 @@ public sealed class GrantsService(IDbContextFactory<ApplicationDbContext> contex
             return Result.OkIf(await context.SaveChangesAsync(cancellationToken) > 0, CreateError.New);
         }));
 
-    public async ValueTask<Result> CreateAwardAsync(CreateAwardRequest request, Guid userId, CancellationToken cancellationToken = default) =>
-        await Result.Try((Func<ValueTask<Result>>)(async () =>
+    public async Task<Result> CreateAwardAsync(CreateAwardRequest request, Guid userId, CancellationToken cancellationToken = default) =>
+        await Result.Try((Func<Task<Result>>)(async () =>
         {
             if (request.Amount <= 0)
                 return Result.Fail(ValidationError.Create("Approved amount must be greater than zero."));
@@ -204,8 +204,8 @@ public sealed class GrantsService(IDbContextFactory<ApplicationDbContext> contex
             return Result.OkIf(await context.SaveChangesAsync(cancellationToken) > 0, CreateError.New);
         }));
 
-    public async ValueTask<Result<string>> GetContractUrlAsync(string contractIdHash, CancellationToken cancellationToken = default) =>
-        await Result.Try((Func<ValueTask<Result<string>>>)(async () =>
+    public async Task<Result<string>> GetContractUrlAsync(string contractIdHash, CancellationToken cancellationToken = default) =>
+        await Result.Try((Func<Task<Result<string>>>)(async () =>
         {
             var decodeResult = hashService.DecodeLongIdHash(contractIdHash);
 
@@ -231,8 +231,8 @@ public sealed class GrantsService(IDbContextFactory<ApplicationDbContext> contex
                     .ToResult(secureDownloadUrlResult.Value);
         }));
 
-    public async ValueTask<Result> UploadContractAsync(string contractIdHash, Guid userId, IFormFile file, CancellationToken cancellationToken = default) =>
-        await Result.Try((Func<ValueTask<Result>>)(async () =>
+    public async Task<Result> UploadContractAsync(string contractIdHash, Guid userId, IFormFile file, CancellationToken cancellationToken = default) =>
+        await Result.Try((Func<Task<Result>>)(async () =>
         {
             var decodeResult = hashService.DecodeLongIdHash(contractIdHash);
 
@@ -261,8 +261,8 @@ public sealed class GrantsService(IDbContextFactory<ApplicationDbContext> contex
                 CreateError.Create("Failed to upload contract file"));
         }));
 
-    public async ValueTask<Result> UpdateContractAsync(UpdateContractRequest request, CancellationToken cancellationToken = default) =>
-        await Result.Try((Func<ValueTask<Result>>)(async () =>
+    public async Task<Result> UpdateContractAsync(UpdateContractRequest request, CancellationToken cancellationToken = default) =>
+        await Result.Try((Func<Task<Result>>)(async () =>
         {
             await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
 

PostFundManagement.Application/Services/Projects/ProjectCacheService.cs

@@ -3,6 +3,7 @@ using PostFundManagement.Application.Abstractions.Services;
 using PostFundManagement.Application.Extensions;
 using PostFundManagement.Application.Services.Shared;
 using PostFundManagement.Domain;
+using PostFundManagement.Domain.Attributes;
 using PostFundManagement.Domain.Models;
 using static PostFundManagement.Domain.Extensions.Constants;
 
@@ -11,17 +12,20 @@ namespace PostFundManagement.Application.Services.Projects;
 public sealed class ProjectCacheService(ProjectService service, IDistributedCache cache,
     IFeatureManager featureManager) : ServiceCacheBase, IProjectService
 {
-    public async ValueTask<Result> CreateActivityAsync(CreateActivityRequest request, Guid userId, CancellationToken cancellationToken = default) =>
+    [Audit]
+    public async Task<Result> CreateActivityAsync(CreateActivityRequest request, Guid userId, CancellationToken cancellationToken = default) =>
         await service.CreateActivityAsync(request, userId, cancellationToken);
 
-    public async ValueTask<Result> CreateProgrammeAsync(CreateProgrammeRequest request, Guid userId, CancellationToken cancellationToken = default) =>
+    [Audit]
+    public async Task<Result> CreateProgrammeAsync(CreateProgrammeRequest request, Guid userId, CancellationToken cancellationToken = default) =>
         await service.CreateProgrammeAsync(request, userId, cancellationToken);
 
-    public async ValueTask<Result> CreateProjectAsync(CreateProjectRequest request, Guid userId, CancellationToken cancellationToken = default) =>
+    [Audit]
+    public async Task<Result> CreateProjectAsync(CreateProjectRequest request, Guid userId, CancellationToken cancellationToken = default) =>
         await service.CreateProjectAsync(request, userId, cancellationToken);
 
-    public async ValueTask<Result<Domain.Models.Activity[]>> GetActivitiesAsync(string projectIdHash, CancellationToken cancellationToken = default) =>
-        await Result.Try((Func<ValueTask<Result<Domain.Models.Activity[]>>>)(async () =>
+    public async Task<Result<Domain.Models.Activity[]>> GetActivitiesAsync(string projectIdHash, CancellationToken cancellationToken = default) =>
+        await Result.Try((Func<Task<Result<Domain.Models.Activity[]>>>)(async () =>
         {
             if (!await featureManager.IsEnabledAsync(ServiceCachingFeature))
                 return await service.GetActivitiesAsync(projectIdHash, cancellationToken);
@@ -44,8 +48,8 @@ public sealed class ProjectCacheService(ProjectService service, IDistributedCach
             return Result.Ok(cached.FromJson<Domain.Models.Activity[]>());
         }));
 
-    public async ValueTask<Result<Domain.Models.Activity>> GetActivityAsync(string activityIdHash, CancellationToken cancellationToken = default) =>
-        await Result.Try((Func<ValueTask<Result<Domain.Models.Activity>>>)(async () =>
+    public async Task<Result<Domain.Models.Activity>> GetActivityAsync(string activityIdHash, CancellationToken cancellationToken = default) =>
+        await Result.Try((Func<Task<Result<Domain.Models.Activity>>>)(async () =>
         {
             if (!await featureManager.IsEnabledAsync(ServiceCachingFeature))
                 return await service.GetActivityAsync(activityIdHash, cancellationToken);
@@ -68,8 +72,8 @@ public sealed class ProjectCacheService(ProjectService service, IDistributedCach
             return Result.Ok(cached.FromJson<Domain.Models.Activity>());
         }));
 
-    public async ValueTask<Result<Milestone>> GetMilestoneAsync(string milestoneIdHash, CancellationToken cancellationToken = default) =>
-        await Result.Try((Func<ValueTask<Result<Milestone>>>)(async () =>
+    public async Task<Result<Milestone>> GetMilestoneAsync(string milestoneIdHash, CancellationToken cancellationToken = default) =>
+        await Result.Try((Func<Task<Result<Milestone>>>)(async () =>
         {
             if (!await featureManager.IsEnabledAsync(ServiceCachingFeature))
                 return await service.GetMilestoneAsync(milestoneIdHash, cancellationToken);
@@ -92,8 +96,8 @@ public sealed class ProjectCacheService(ProjectService service, IDistributedCach
             return Result.Ok(cached.FromJson<Milestone>());
         }));
 
-    public async ValueTask<Result<Milestone[]>> GetMilestonesAsync(Pagination pagination, CancellationToken cancellationToken = default) =>
-        await Result.Try((Func<ValueTask<Result<Milestone[]>>>)(async () =>
+    public async Task<Result<Milestone[]>> GetMilestonesAsync(Pagination pagination, CancellationToken cancellationToken = default) =>
+        await Result.Try((Func<Task<Result<Milestone[]>>>)(async () =>
         {
             if (!await featureManager.IsEnabledAsync(ServiceCachingFeature))
                 return await service.GetMilestonesAsync(pagination, cancellationToken);
@@ -116,8 +120,8 @@ public sealed class ProjectCacheService(ProjectService service, IDistributedCach
             return Result.Ok(cached.FromJson<Milestone[]>());
         }));
 
-    public async ValueTask<Result<Programme>> GetProgrammeAsync(string programmeIdHash, CancellationToken cancellationToken = default) =>
-        await Result.Try((Func<ValueTask<Result<Programme>>>)(async () =>
+    public async Task<Result<Programme>> GetProgrammeAsync(string programmeIdHash, CancellationToken cancellationToken = default) =>
+        await Result.Try((Func<Task<Result<Programme>>>)(async () =>
         {
             if (!await featureManager.IsEnabledAsync(ServiceCachingFeature))
                 return await service.GetProgrammeAsync(programmeIdHash, cancellationToken);
@@ -140,8 +144,8 @@ public sealed class ProjectCacheService(ProjectService service, IDistributedCach
             return Result.Ok(cached!.FromJson<Programme>());
         }));
 
-    public async ValueTask<Result<Project[]>> GetProgrammeProjectsAsync(string programmeIdHash, CancellationToken cancellationToken = default) =>
-        await Result.Try((Func<ValueTask<Result<Project[]>>>)(async () =>
+    public async Task<Result<Project[]>> GetProgrammeProjectsAsync(string programmeIdHash, CancellationToken cancellationToken = default) =>
+        await Result.Try((Func<Task<Result<Project[]>>>)(async () =>
         {
             if (!await featureManager.IsEnabledAsync(ServiceCachingFeature))
                 return await service.GetProgrammeProjectsAsync(programmeIdHash, cancellationToken);
@@ -164,8 +168,8 @@ public sealed class ProjectCacheService(ProjectService service, IDistributedCach
             return Result.Ok(cached.FromJson<Project[]>());
         }));
 
-    public async ValueTask<Result<Programme[]>> GetProgrammesAsync(Pagination pagination, CancellationToken cancellationToken = default) =>
-        await Result.Try((Func<ValueTask<Result<Programme[]>>>)(async () =>
+    public async Task<Result<Programme[]>> GetProgrammesAsync(Pagination pagination, CancellationToken cancellationToken = default) =>
+        await Result.Try((Func<Task<Result<Programme[]>>>)(async () =>
         {
             if (!await featureManager.IsEnabledAsync(ServiceCachingFeature))
                 return await service.GetProgrammesAsync(pagination, cancellationToken);
@@ -188,8 +192,8 @@ public sealed class ProjectCacheService(ProjectService service, IDistributedCach
             return Result.Ok(cached.FromJson<Programme[]>());
         }));
 
-    public async ValueTask<Result<Project>> GetProjectAsync(string projectIdHash, CancellationToken cancellationToken = default) =>
-        await Result.Try((Func<ValueTask<Result<Project>>>)(async () =>
+    public async Task<Result<Project>> GetProjectAsync(string projectIdHash, CancellationToken cancellationToken = default) =>
+        await Result.Try((Func<Task<Result<Project>>>)(async () =>
         {
             if (!await featureManager.IsEnabledAsync(ServiceCachingFeature))
                 return await service.GetProjectAsync(projectIdHash, cancellationToken);
@@ -212,8 +216,8 @@ public sealed class ProjectCacheService(ProjectService service, IDistributedCach
             return Result.Ok(cached.FromJson<Project>());
         }));
 
-    public async ValueTask<Result<Indicator[]>> GetProjectIndicatorsAsync(string projectIdHash, CancellationToken cancellationToken = default) =>
-        await Result.Try((Func<ValueTask<Result<Indicator[]>>>)(async () =>
+    public async Task<Result<Indicator[]>> GetProjectIndicatorsAsync(string projectIdHash, CancellationToken cancellationToken = default) =>
+        await Result.Try((Func<Task<Result<Indicator[]>>>)(async () =>
         {
             if (!await featureManager.IsEnabledAsync(ServiceCachingFeature))
                 return await service.GetProjectIndicatorsAsync(projectIdHash, cancellationToken);
@@ -236,8 +240,8 @@ public sealed class ProjectCacheService(ProjectService service, IDistributedCach
             return Result.Ok(cached.FromJson<Indicator[]>());
         }));
 
-    public async ValueTask<Result<Milestone[]>> GetProjectMilestonesAsync(string projectIdHash, CancellationToken cancellationToken = default) =>
-        await Result.Try((Func<ValueTask<Result<Milestone[]>>>)(async () =>
+    public async Task<Result<Milestone[]>> GetProjectMilestonesAsync(string projectIdHash, CancellationToken cancellationToken = default) =>
+        await Result.Try((Func<Task<Result<Milestone[]>>>)(async () =>
         {
             if (!await featureManager.IsEnabledAsync(ServiceCachingFeature))
                 return await service.GetProjectMilestonesAsync(projectIdHash, cancellationToken);
@@ -260,8 +264,8 @@ public sealed class ProjectCacheService(ProjectService service, IDistributedCach
             return Result.Ok(cached.FromJson<Milestone[]>());
         }));
 
-    public async ValueTask<Result<Risk[]>> GetProjectRisksAsync(string projectIdHash, CancellationToken cancellationToken = default) =>
-        await Result.Try((Func<ValueTask<Result<Risk[]>>>)(async () =>
+    public async Task<Result<Risk[]>> GetProjectRisksAsync(string projectIdHash, CancellationToken cancellationToken = default) =>
+        await Result.Try((Func<Task<Result<Risk[]>>>)(async () =>
         {
             if (!await featureManager.IsEnabledAsync(ServiceCachingFeature))
                 return await service.GetProjectRisksAsync(projectIdHash, cancellationToken);
@@ -284,8 +288,8 @@ public sealed class ProjectCacheService(ProjectService service, IDistributedCach
             return Result.Ok(cached.FromJson<Risk[]>());
         }));
 
-    public async ValueTask<Result<Project[]>> GetProjectsAsync(Pagination pagination, CancellationToken cancellationToken = default) =>
-        await Result.Try((Func<ValueTask<Result<Project[]>>>)(async () =>
+    public async Task<Result<Project[]>> GetProjectsAsync(Pagination pagination, CancellationToken cancellationToken = default) =>
+        await Result.Try((Func<Task<Result<Project[]>>>)(async () =>
         {
             if (!await featureManager.IsEnabledAsync(ServiceCachingFeature))
                 return await service.GetProjectsAsync(pagination, cancellationToken);
@@ -308,15 +312,19 @@ public sealed class ProjectCacheService(ProjectService service, IDistributedCach
             return Result.Ok(cached.FromJson<Project[]>());
         }));
 
-    public async ValueTask<Result> UpdateMilestoneAsync(UpdateMilestoneRequest request, Guid userId, CancellationToken cancellationToken = default) =>
+    [Audit]
+    public async Task<Result> UpdateMilestoneAsync(UpdateMilestoneRequest request, Guid userId, CancellationToken cancellationToken = default) =>
         await service.UpdateMilestoneAsync(request, userId, cancellationToken);
 
-    public async ValueTask<Result> UpdateProgrammeAsync(UpdateProgrammeRequest request, Guid userId, CancellationToken cancellationToken = default) =>
+    [Audit]
+    public async Task<Result> UpdateProgrammeAsync(UpdateProgrammeRequest request, Guid userId, CancellationToken cancellationToken = default) =>
         await service.UpdateProgrammeAsync(request, userId, cancellationToken);
 
-    public async ValueTask<Result> UpdateProjectAsync(UpdateProjectRequest request, Guid userId, CancellationToken cancellationToken = default) =>
+    [Audit]
+    public async Task<Result> UpdateProjectAsync(UpdateProjectRequest request, Guid userId, CancellationToken cancellationToken = default) =>
         await service.UpdateProjectAsync(request, userId, cancellationToken);
 
-    public async ValueTask<Result> UpdateProjectStatusAsync(UpdateProjectStatusRequest request, Guid userId, CancellationToken cancellationToken = default) =>
+    [Audit]
+    public async Task<Result> UpdateProjectStatusAsync(UpdateProjectStatusRequest request, Guid userId, CancellationToken cancellationToken = default) =>
         await service.UpdateProjectStatusAsync(request, userId, cancellationToken);
 }

PostFundManagement.Application/Services/Projects/ProjectService.cs

@@ -10,8 +10,8 @@ namespace PostFundManagement.Application.Services.Projects;
 
 public sealed class ProjectService(IDbContextFactory<ApplicationDbContext> contextFactory, HashService hashService) : IProjectService
 {
-    public async ValueTask<Result> UpdateProjectStatusAsync(UpdateProjectStatusRequest request, Guid userId, CancellationToken cancellationToken = default) =>
-        await Result.Try((Func<ValueTask<Result>>)(async () =>
+    public async Task<Result> UpdateProjectStatusAsync(UpdateProjectStatusRequest request, Guid userId, CancellationToken cancellationToken = default) =>
+        await Result.Try((Func<Task<Result>>)(async () =>
         {
             await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
 
@@ -28,8 +28,8 @@ public sealed class ProjectService(IDbContextFactory<ApplicationDbContext> conte
             return Result.OkIf(changedTotal > 0, UpdateError.Create("No changes detected, update cancelled."));
         }));
 
-    public async ValueTask<Result<Project[]>> GetProjectsAsync(Pagination pagination, CancellationToken cancellationToken = default) =>
-        await Result.Try((Func<ValueTask<Result<Project[]>>>)(async () =>
+    public async Task<Result<Project[]>> GetProjectsAsync(Pagination pagination, CancellationToken cancellationToken = default) =>
+        await Result.Try((Func<Task<Result<Project[]>>>)(async () =>
         {
             await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
 
@@ -41,8 +41,8 @@ public sealed class ProjectService(IDbContextFactory<ApplicationDbContext> conte
             return Result.Ok(projects.Select(p => p.Map()).ToArray());
         }));
 
-    public async ValueTask<Result<Project>> GetProjectAsync(string projectIdHash, CancellationToken cancellationToken = default) =>
-        await Result.Try((Func<ValueTask<Result<Project>>>)(async () =>
+    public async Task<Result<Project>> GetProjectAsync(string projectIdHash, CancellationToken cancellationToken = default) =>
+        await Result.Try((Func<Task<Result<Project>>>)(async () =>
         {
             var decodeResult = hashService.DecodeLongIdHash(projectIdHash);
 
@@ -59,8 +59,8 @@ public sealed class ProjectService(IDbContextFactory<ApplicationDbContext> conte
                 .ToResult(project!.Map());
         }));
 
-    public async ValueTask<Result<Domain.Models.Activity[]>> GetActivitiesAsync(string projectIdHash, CancellationToken cancellationToken = default) =>
-        await Result.Try((Func<ValueTask<Result<Domain.Models.Activity[]>>>)(async () =>
+    public async Task<Result<Domain.Models.Activity[]>> GetActivitiesAsync(string projectIdHash, CancellationToken cancellationToken = default) =>
+        await Result.Try((Func<Task<Result<Domain.Models.Activity[]>>>)(async () =>
         {
             var decodeResult = hashService.DecodeLongIdHash(projectIdHash);
 
@@ -77,8 +77,8 @@ public sealed class ProjectService(IDbContextFactory<ApplicationDbContext> conte
             return Result.Ok(activities.Select(a => a.Map()).ToArray());
         }));
 
-    public async ValueTask<Result> CreateProjectAsync(CreateProjectRequest request, Guid userId, CancellationToken cancellationToken = default) =>
-        await Result.Try((Func<ValueTask<Result>>)(async () =>
+    public async Task<Result> CreateProjectAsync(CreateProjectRequest request, Guid userId, CancellationToken cancellationToken = default) =>
+        await Result.Try((Func<Task<Result>>)(async () =>
         {
             using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
 
@@ -108,8 +108,8 @@ public sealed class ProjectService(IDbContextFactory<ApplicationDbContext> conte
                 CreateError.Create("No changes detected, update cancelled."));
         }));
 
-    public async ValueTask<Result> CreateActivityAsync(CreateActivityRequest request, Guid userId, CancellationToken cancellationToken = default) =>
-        await Result.Try((Func<ValueTask<Result>>)(async () =>
+    public async Task<Result> CreateActivityAsync(CreateActivityRequest request, Guid userId, CancellationToken cancellationToken = default) =>
+        await Result.Try((Func<Task<Result>>)(async () =>
         {
             await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
 
@@ -138,8 +138,8 @@ public sealed class ProjectService(IDbContextFactory<ApplicationDbContext> conte
                 CreateError.Create("No record was created."));
         }));
 
-    public async ValueTask<Result<Milestone[]>> GetProjectMilestonesAsync(string projectIdHash, CancellationToken cancellationToken = default) =>
-        await Result.Try((Func<ValueTask<Result<Milestone[]>>>)(async () =>
+    public async Task<Result<Milestone[]>> GetProjectMilestonesAsync(string projectIdHash, CancellationToken cancellationToken = default) =>
+        await Result.Try((Func<Task<Result<Milestone[]>>>)(async () =>
         {
             var decodeResult = hashService.DecodeLongIdHash(projectIdHash);
 
@@ -157,8 +157,8 @@ public sealed class ProjectService(IDbContextFactory<ApplicationDbContext> conte
             return Result.Ok(milestones.Select(i => i.Map()).ToArray());
         }));
 
-    public async ValueTask<Result<Indicator[]>> GetProjectIndicatorsAsync(string projectIdHash, CancellationToken cancellationToken) =>
-        await Result.Try((Func<ValueTask<Result<Indicator[]>>>)(async () =>
+    public async Task<Result<Indicator[]>> GetProjectIndicatorsAsync(string projectIdHash, CancellationToken cancellationToken) =>
+        await Result.Try((Func<Task<Result<Indicator[]>>>)(async () =>
         {
             var decodeResult = hashService.DecodeLongIdHash(projectIdHash);
 
@@ -176,8 +176,8 @@ public sealed class ProjectService(IDbContextFactory<ApplicationDbContext> conte
             return Result.Ok(evidences.Select(e => e.Map()).ToArray());
         }));
 
-    public async ValueTask<Result<Milestone>> GetMilestoneAsync(string milestoneIdHash, CancellationToken cancellationToken = default) =>
-        await Result.Try((Func<ValueTask<Result<Milestone>>>)(async () =>
+    public async Task<Result<Milestone>> GetMilestoneAsync(string milestoneIdHash, CancellationToken cancellationToken = default) =>
+        await Result.Try((Func<Task<Result<Milestone>>>)(async () =>
         {
             var decodeResult = hashService.DecodeLongIdHash(milestoneIdHash);
 
@@ -193,8 +193,8 @@ public sealed class ProjectService(IDbContextFactory<ApplicationDbContext> conte
                 .ToResult(milestone!.Map());
         }));
 
-    public async ValueTask<Result<Milestone[]>> GetMilestonesAsync(Pagination pagination, CancellationToken cancellationToken = default) =>
-        await Result.Try((Func<ValueTask<Result<Milestone[]>>>)(async () =>
+    public async Task<Result<Milestone[]>> GetMilestonesAsync(Pagination pagination, CancellationToken cancellationToken = default) =>
+        await Result.Try((Func<Task<Result<Milestone[]>>>)(async () =>
         {
             await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
 
@@ -207,8 +207,8 @@ public sealed class ProjectService(IDbContextFactory<ApplicationDbContext> conte
             return Result.Ok(milestones.Select(i => i.Map()).ToArray());
         }));
 
-    public async ValueTask<Result> UpdateMilestoneAsync(UpdateMilestoneRequest request, Guid userId, CancellationToken cancellationToken = default) =>
-        await Result.Try((Func<ValueTask<Result>>)(async () =>
+    public async Task<Result> UpdateMilestoneAsync(UpdateMilestoneRequest request, Guid userId, CancellationToken cancellationToken = default) =>
+        await Result.Try((Func<Task<Result>>)(async () =>
         {
             await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
 
@@ -227,8 +227,8 @@ public sealed class ProjectService(IDbContextFactory<ApplicationDbContext> conte
             return Result.OkIf(changedTotal > 0, UpdateError.Create("No changes detected, update cancelled."));
         }));
 
-    public async ValueTask<Result> UpdateProjectAsync(UpdateProjectRequest request, Guid userId, CancellationToken cancellationToken = default) =>
-        await Result.Try((Func<ValueTask<Result>>)(async () =>
+    public async Task<Result> UpdateProjectAsync(UpdateProjectRequest request, Guid userId, CancellationToken cancellationToken = default) =>
+        await Result.Try((Func<Task<Result>>)(async () =>
         {
             await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
 
@@ -246,8 +246,8 @@ public sealed class ProjectService(IDbContextFactory<ApplicationDbContext> conte
             return Result.OkIf(changedTotal > 0, UpdateError.Create("No changes detected, update cancelled."));
         }));
 
-    public async ValueTask<Result<Domain.Models.Activity>> GetActivityAsync(string activityIdHash, CancellationToken cancellationToken = default) =>
-        await Result.Try((Func<ValueTask<Result<Domain.Models.Activity>>>)(async () =>
+    public async Task<Result<Domain.Models.Activity>> GetActivityAsync(string activityIdHash, CancellationToken cancellationToken = default) =>
+        await Result.Try((Func<Task<Result<Domain.Models.Activity>>>)(async () =>
         {
             var decodeResult = hashService.DecodeLongIdHash(activityIdHash);
 
@@ -264,8 +264,8 @@ public sealed class ProjectService(IDbContextFactory<ApplicationDbContext> conte
                 .ToResult(activity!.Map());
         }));
 
-    public async ValueTask<Result<Risk[]>> GetProjectRisksAsync(string projectIdHash, CancellationToken cancellationToken = default) =>
-        await Result.Try((Func<ValueTask<Result<Risk[]>>>)(async () =>
+    public async Task<Result<Risk[]>> GetProjectRisksAsync(string projectIdHash, CancellationToken cancellationToken = default) =>
+        await Result.Try((Func<Task<Result<Risk[]>>>)(async () =>
         {
             var decodeResult = hashService.DecodeLongIdHash(projectIdHash);
 
@@ -283,8 +283,8 @@ public sealed class ProjectService(IDbContextFactory<ApplicationDbContext> conte
             return Result.Ok(risks.Select(i => i.Map()).ToArray());
         }));
 
-    public async ValueTask<Result> CreateProgrammeAsync(CreateProgrammeRequest request, Guid userId, CancellationToken cancellationToken = default) =>
-        await Result.Try((Func<ValueTask<Result>>)(async () =>
+    public async Task<Result> CreateProgrammeAsync(CreateProgrammeRequest request, Guid userId, CancellationToken cancellationToken = default) =>
+        await Result.Try((Func<Task<Result>>)(async () =>
         {
             await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
 
@@ -309,8 +309,8 @@ public sealed class ProjectService(IDbContextFactory<ApplicationDbContext> conte
             return Result.OkIf(await context.SaveChangesAsync(cancellationToken) > 0, CreateError.New);
         }));
 
-    public async ValueTask<Result> UpdateProgrammeAsync(UpdateProgrammeRequest request, Guid userId, CancellationToken cancellationToken = default) =>
-        await Result.Try((Func<ValueTask<Result>>)(async () =>
+    public async Task<Result> UpdateProgrammeAsync(UpdateProgrammeRequest request, Guid userId, CancellationToken cancellationToken = default) =>
+        await Result.Try((Func<Task<Result>>)(async () =>
         {
             await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
 
@@ -328,8 +328,8 @@ public sealed class ProjectService(IDbContextFactory<ApplicationDbContext> conte
             return Result.OkIf(changedTotal > 0, UpdateError.Create("No changes detected, update cancelled."));
         }));
 
-    public async ValueTask<Result<Programme>> GetProgrammeAsync(string programmeIdHash, CancellationToken cancellationToken = default) =>
-        await Result.Try((Func<ValueTask<Result<Programme>>>)(async () =>
+    public async Task<Result<Programme>> GetProgrammeAsync(string programmeIdHash, CancellationToken cancellationToken = default) =>
+        await Result.Try((Func<Task<Result<Programme>>>)(async () =>
         {
             var decodeResult = hashService.DecodeLongIdHash(programmeIdHash);
 
@@ -344,8 +344,8 @@ public sealed class ProjectService(IDbContextFactory<ApplicationDbContext> conte
                 .ToResult(programme!.Map());
         }));
 
-    public async ValueTask<Result<Programme[]>> GetProgrammesAsync(Pagination pagination, CancellationToken cancellationToken = default) =>
-        await Result.Try((Func<ValueTask<Result<Programme[]>>>)(async () =>
+    public async Task<Result<Programme[]>> GetProgrammesAsync(Pagination pagination, CancellationToken cancellationToken = default) =>
+        await Result.Try((Func<Task<Result<Programme[]>>>)(async () =>
         {
             await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
 
@@ -358,8 +358,8 @@ public sealed class ProjectService(IDbContextFactory<ApplicationDbContext> conte
             return Result.Ok(programmes.Select(i => i.Map()).ToArray());
         }));
 
-    public async ValueTask<Result<Project[]>> GetProgrammeProjectsAsync(string programmeIdHash, CancellationToken cancellationToken = default) =>
-        await Result.Try((Func<ValueTask<Result<Project[]>>>)(async () =>
+    public async Task<Result<Project[]>> GetProgrammeProjectsAsync(string programmeIdHash, CancellationToken cancellationToken = default) =>
+        await Result.Try((Func<Task<Result<Project[]>>>)(async () =>
         {
             var decodeResult = hashService.DecodeLongIdHash(programmeIdHash);
 

PostFundManagement.Application/Services/Shared/AuditService.cs

@@ -6,8 +6,8 @@ namespace PostFundManagement.Application.Services.Shared;
 
 public sealed class AuditService(IDbContextFactory<ApplicationDbContext> contextFactory, ITenantContextService tenantContextService) : IService
 {
-    public async ValueTask<Result> LogActionAsync(string entityId, string entityName, string action, string[] changes, Guid performedBy, CancellationToken cancellationToken = default) =>
-        await Result.Try((Func<ValueTask<Result>>)(async () =>
+    public async Task<Result> LogActionAsync(string entityId, string entityName, string action, string[] changes, Guid performedBy, CancellationToken cancellationToken = default) =>
+        await Result.Try((Func<Task<Result>>)(async () =>
         {
             await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
 

PostFundManagement.Application/Services/Shared/BrowserLocalStorageService.cs

@@ -4,32 +4,32 @@ namespace PostFundManagement.Application.Services.Shared;
 
 public sealed class BrowserLocalStorageService(ProtectedLocalStorage storage)
 {
-    public async ValueTask<Result> DeleteAsync(string key) =>
-        await Result.Try((Func<ValueTask<Result>>)(async () =>
+    public async Task<Result> DeleteAsync(string key) =>
+        await Result.Try((Func<Task<Result>>)(async () =>
         {
             await storage.DeleteAsync(key);
 
             return Result.Ok();
         }));
 
-    public async ValueTask<Result> SaveAsync(string key, string value) =>
-        await Result.Try((Func<ValueTask<Result>>)(async () =>
+    public async Task<Result> SaveAsync(string key, string value) =>
+        await Result.Try((Func<Task<Result>>)(async () =>
         {
             await storage.SetAsync(key, value);
 
             return Result.Ok();
         }));
 
-    public async ValueTask<Result> SaveAsync<TValue>(string key, TValue value) where TValue : class =>
-        await Result.Try((Func<ValueTask<Result>>)(async () =>
+    public async Task<Result> SaveAsync<TValue>(string key, TValue value) where TValue : class =>
+        await Result.Try((Func<Task<Result>>)(async () =>
         {
             await storage.SetAsync(key, value);
 
             return Result.Ok();
         }));
 
-    public async ValueTask<Result<string>> GetAsync(string key) =>
-        await Result.Try((Func<ValueTask<Result<string>>>)(async () =>
+    public async Task<Result<string>> GetAsync(string key) =>
+        await Result.Try((Func<Task<Result<string>>>)(async () =>
         {
             var retrieval = await storage.GetAsync<string>(key);
 
@@ -38,8 +38,8 @@ public sealed class BrowserLocalStorageService(ProtectedLocalStorage storage)
                     .ToResult(retrieval.Value!);
         }));
 
-    public async ValueTask<Result<TValue>> GetAsync<TValue>(string key) where TValue : class =>
-        await Result.Try((Func<ValueTask<Result<TValue>>>)(async () =>
+    public async Task<Result<TValue>> GetAsync<TValue>(string key) where TValue : class =>
+        await Result.Try((Func<Task<Result<TValue>>>)(async () =>
         {
             var retrieval = await storage.GetAsync<TValue>(key);
 

PostFundManagement.Application/Services/Shared/EmailService.cs

@@ -17,7 +17,7 @@ public sealed class EmailService(IOptions<SmtpSettings> options) : IDisposable
 
     public EmailStatuses Status { get; private set; } = EmailStatuses.Disconnected;
 
-    public async ValueTask<Result<Response>> SendEmailAsync(Message message, CancellationToken cancellationToken = default)
+    public async Task<Result<Response>> SendEmailAsync(Message message, CancellationToken cancellationToken = default)
     {
         using var activity = EmailTelemetry.Source.StartActivity("Email Send");
 
@@ -121,7 +121,7 @@ public sealed class EmailService(IOptions<SmtpSettings> options) : IDisposable
         return Result.Fail<Response>(response);
     }
 
-    public async ValueTask<Result<Response>> ConnectAsync(CancellationToken cancellationToken = default)
+    public async Task<Result<Response>> ConnectAsync(CancellationToken cancellationToken = default)
     {
         using var activity = EmailTelemetry.Source.StartActivity("Email Connect");
         activity?.SetTag("email.smtp.connect", settings.Host);
@@ -174,7 +174,7 @@ public sealed class EmailService(IOptions<SmtpSettings> options) : IDisposable
         }
     }
 
-    public async ValueTask<Result> DisconnectAsync(CancellationToken cancellationToken = default)
+    public async Task<Result> DisconnectAsync(CancellationToken cancellationToken = default)
     {
         using var activity = EmailTelemetry.Source.StartActivity("Email Disconnect");
         activity?.SetTag("email.smtp.disconnect", settings.Host);

PostFundManagement.Application/Services/Shared/HashService.cs

@@ -67,7 +67,7 @@ public sealed partial class HashService(IHashids hasher) : IService
     }
 
     public async Task<Result<string>> DecodeHexHash(string hex) =>
-        await Result.Try((Func<ValueTask<Result<string>>>)(async () =>
+        await Result.Try((Func<Task<Result<string>>>)(async () =>
         {
             string decoded = hasher.DecodeHex(hex);
 

PostFundManagement.Application/Services/Shared/IdentityCacheService.cs

@@ -5,6 +5,6 @@ namespace PostFundManagement.Application.Services.Shared;
 
 public sealed class IdentityCacheService(IdentityService service) : ServiceCacheBase, IIdentityService
 {
-    public async ValueTask<Result> UserIsAuthorisedAsync(Guid userId, CancellationToken cancellationToken = default) =>
+    public async Task<Result> UserIsAuthorisedAsync(Guid userId, CancellationToken cancellationToken = default) =>
         await service.UserIsAuthorisedAsync(userId, cancellationToken);
 }

PostFundManagement.Application/Services/Shared/IdentityService.cs

@@ -7,8 +7,8 @@ namespace PostFundManagement.Application.Services.Shared;
 
 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 () =>
+    public async Task<Result> UserIsAuthorisedAsync(Guid userId, CancellationToken cancellationToken = default) =>
+        await Result.Try((Func<Task<Result>>)(async () =>
         {
             await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
 

PostFundManagement.Application/Services/Shared/TokenService.cs

@@ -9,8 +9,8 @@ public sealed class TokenService(ISecurityConnectApi connectApi, IOptions<Securi
 {
     private readonly SecurityClientSettings clientSettings = clientOptions.Value;
 
-    public async ValueTask<Result<Domain.Security.Models.TokenResponse>> GenerateAsync(CancellationToken cancellationToken = default) =>
-        await Result.Try((Func<ValueTask<Result<Domain.Security.Models.TokenResponse>>>)(async () =>
+    public async Task<Result<Domain.Security.Models.TokenResponse>> GenerateAsync(CancellationToken cancellationToken = default) =>
+        await Result.Try((Func<Task<Result<Domain.Security.Models.TokenResponse>>>)(async () =>
         {
             using var response = await connectApi.GetToken(new Domain.Security.Models.TokenRequest
             {
@@ -34,7 +34,7 @@ public sealed class TokenService(ISecurityConnectApi connectApi, IOptions<Securi
                             .ToResult(tokenResponse!);
             }
 
-            return await Result.Try((Func<ValueTask<Result<Domain.Security.Models.TokenResponse>>>)(async () =>
+            return await Result.Try((Func<Task<Result<Domain.Security.Models.TokenResponse>>>)(async () =>
             {
                 var errorResult = JsonSerializer.Deserialize<TokenErrorResponse>(contentRaw);
 

PostFundManagement.Application/Services/Tools/ToolCacheService.cs

@@ -8,8 +8,8 @@ namespace PostFundManagement.Application.Services.Tools;
 public sealed class ToolCacheService(ToolService service, IDistributedCache cache, 
     IFeatureManager featureManager) : ServiceCacheBase, IToolService
 {
-    public async ValueTask<Result<string>> EncodeLong(long id, CancellationToken cancellationToken) =>
-        await Result.Try((Func<ValueTask<Result<string>>>)(async () =>
+    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);

PostFundManagement.Application/Services/Tools/ToolService.cs

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

PostFundManagement.Application/Services/Users/UserCacheService.cs

@@ -3,6 +3,7 @@ using PostFundManagement.Application.Abstractions.Services;
 using PostFundManagement.Application.Extensions;
 using PostFundManagement.Application.Services.Shared;
 using PostFundManagement.Domain;
+using PostFundManagement.Domain.Attributes;
 using PostFundManagement.Domain.Models;
 using static PostFundManagement.Domain.Extensions.Constants;
 
@@ -11,8 +12,8 @@ namespace PostFundManagement.Application.Services.Users;
 public sealed class UserCacheService(UserService service, IDistributedCache cache, 
     IFeatureManager featureManager) : ServiceCacheBase, IUserService
 {
-    public async ValueTask<Result<User>> GetUserAsync(Guid userId, CancellationToken cancellationToken) =>
-        await Result.Try((Func<ValueTask<Result<User>>>)(async () =>
+    public async Task<Result<User>> GetUserAsync(Guid userId, CancellationToken cancellationToken) =>
+        await Result.Try((Func<Task<Result<User>>>)(async () =>
         {
             if (!await featureManager.IsEnabledAsync(ServiceCachingFeature))
                 return await service.GetUserAsync(userId, cancellationToken);
@@ -35,8 +36,8 @@ public sealed class UserCacheService(UserService service, IDistributedCache cach
             return Result.Ok(cached.FromJson<User>());
         }));
 
-    public async ValueTask<Result<User[]>> GetUsersAsync(Pagination pagination, UserFilterRequest request, CancellationToken cancellationToken = default) =>
-        await Result.Try((Func<ValueTask<Result<User[]>>>)(async () =>
+    public async Task<Result<User[]>> GetUsersAsync(Pagination pagination, UserFilterRequest request, CancellationToken cancellationToken = default) =>
+        await Result.Try((Func<Task<Result<User[]>>>)(async () =>
         {
             if (!await featureManager.IsEnabledAsync(ServiceCachingFeature))
                 return await service.GetUsersAsync(pagination, request, cancellationToken);
@@ -61,9 +62,11 @@ public sealed class UserCacheService(UserService service, IDistributedCache cach
             return Result.Ok(cached.FromJson<User[]>());
         }));
 
-    public async ValueTask<Result> SyncUserAsync(Guid userId, string email, CancellationToken cancellationToken = default) =>
+    [Audit]
+    public async Task<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) =>
+    [Audit]
+    public async Task<Result> UpdateUserStatusAsync(Guid userId, ActivityStatus status, CancellationToken cancellationToken = default) =>
         await service.UpdateUserStatusAsync(userId, status, cancellationToken);
 }

PostFundManagement.Application/Services/Users/UserService.cs

@@ -9,8 +9,8 @@ namespace PostFundManagement.Application.Services.Users;
 
 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 () =>
+    public async Task<Result> SyncUserAsync(Guid userId, string email, CancellationToken cancellationToken = default) =>
+        await Result.Try((Func<Task<Result>>)(async () =>
         {
             await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
 
@@ -35,8 +35,8 @@ public sealed class UserService(IDbContextFactory<ApplicationDbContext> contextF
             return Result.OkIf(await context.SaveChangesAsync(cancellationToken) > 0, CreateError.New);
         }));
 
-    public async ValueTask<Result<User[]>> GetUsersAsync(Pagination pagination, UserFilterRequest request, CancellationToken cancellationToken = default) =>
-        await Result.Try((Func<ValueTask<Result<User[]>>>)(async () =>
+    public async Task<Result<User[]>> GetUsersAsync(Pagination pagination, UserFilterRequest request, CancellationToken cancellationToken = default) =>
+        await Result.Try((Func<Task<Result<User[]>>>)(async () =>
         {
             await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
 
@@ -65,8 +65,8 @@ public sealed class UserService(IDbContextFactory<ApplicationDbContext> contextF
             return Result.Ok(users.Select(u => u.Map()).ToArray());
         }));
 
-    public async ValueTask<Result> UpdateUserStatusAsync(Guid userId, ActivityStatus status, CancellationToken cancellationToken = default) =>
-        await Result.Try((Func<ValueTask<Result>>)(async () =>
+    public async Task<Result> UpdateUserStatusAsync(Guid userId, ActivityStatus status, CancellationToken cancellationToken = default) =>
+        await Result.Try((Func<Task<Result>>)(async () =>
         {
             await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
 
@@ -77,8 +77,8 @@ public sealed class UserService(IDbContextFactory<ApplicationDbContext> contextF
             return Result.OkIf(changedTotal > 0, UpdateError.New);
         }));
 
-    public async ValueTask<Result<User>> GetUserAsync(Guid userId, CancellationToken cancellationToken) =>
-        await Result.Try((Func<ValueTask<Result<User>>>)(async () =>
+    public async Task<Result<User>> GetUserAsync(Guid userId, CancellationToken cancellationToken) =>
+        await Result.Try((Func<Task<Result<User>>>)(async () =>
         {
             await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
 

PostFundManagement.Domain/Abstractions/IS3Service.cs

@@ -3,7 +3,7 @@ namespace PostFundManagement.Domain.Abstractions;
 public interface IS3Service
 {
     string GenerateCdnUrl(string fileKey);
-    ValueTask<Result<string>> GeneratePresignedUrlAsync(string fileKey, TimeSpan duration, string? contentType = null, CancellationToken cancellationToken = default);    
-    ValueTask<Result<string>> UploadFileAsync(string fileName, string subPath, Stream fileStream, string contentType, CancellationToken cancellationToken = default);
-    ValueTask<Result> DeleteFileAsync(string fileKey, CancellationToken cancellationToken = default);
+    Task<Result<string>> GeneratePresignedUrlAsync(string fileKey, TimeSpan duration, string? contentType = null, CancellationToken cancellationToken = default);    
+    Task<Result<string>> UploadFileAsync(string fileName, string subPath, Stream fileStream, string contentType, CancellationToken cancellationToken = default);
+    Task<Result> DeleteFileAsync(string fileKey, CancellationToken cancellationToken = default);
 }

PostFundManagement.Domain/Entities/AuditLog.cs

@@ -3,12 +3,7 @@ using static PostFundManagement.Domain.Extensions.Constants;
 namespace PostFundManagement.Domain.Entities;
 
 [EntityTypeConfiguration<AuditLogConfiguration, AuditLog>]
-public class AuditLog : Models.AuditLog
-{
-    public virtual Tenant? Tenant { get; set; }
-
-    public virtual User? Performer { get; set; }
-}
+public class AuditLog : Models.AuditLog;
 
 public sealed class AuditLogConfiguration : IEntityTypeConfiguration<AuditLog>
 {
@@ -24,17 +19,5 @@ public sealed class AuditLogConfiguration : IEntityTypeConfiguration<AuditLog>
         builder.Property(f => f.Changes).IsRequired(false).HasColumnType("jsonb");
         builder.Property(f => f.PerformedBy).IsRequired();
         builder.Property(f => f.Timestamp).IsRequired().HasDefaultValueSql("now()");
-
-        builder.HasOne(f => f.Tenant)
-            .WithMany()
-            .HasForeignKey(fk => fk.TenantId)
-            .IsRequired(false)
-            .OnDelete(DeleteBehavior.NoAction);
-
-        builder.HasOne(f => f.Performer)
-               .WithMany()
-               .HasForeignKey(fk => fk.PerformedBy)
-               .IsRequired()
-               .OnDelete(DeleteBehavior.Restrict);
     }
 }

PostFundManagement.Infrastructure/Database/Migrations/20260922033954_RemovedRelationshipsFromAuditLog.cs

@@ -0,0 +1,59 @@
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace PostFundManagement.Infrastructure.Database.Migrations
+{
+    /// <inheritdoc />
+    public partial class RemovedRelationshipsFromAuditLog : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropForeignKey(
+                name: "FK_AuditLogs_Tenants_TenantId",
+                table: "AuditLogs");
+
+            migrationBuilder.DropForeignKey(
+                name: "FK_AuditLogs_Users_PerformedBy",
+                table: "AuditLogs");
+
+            migrationBuilder.DropIndex(
+                name: "IX_AuditLogs_PerformedBy",
+                table: "AuditLogs");
+
+            migrationBuilder.DropIndex(
+                name: "IX_AuditLogs_TenantId",
+                table: "AuditLogs");
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.CreateIndex(
+                name: "IX_AuditLogs_PerformedBy",
+                table: "AuditLogs",
+                column: "PerformedBy");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_AuditLogs_TenantId",
+                table: "AuditLogs",
+                column: "TenantId");
+
+            migrationBuilder.AddForeignKey(
+                name: "FK_AuditLogs_Tenants_TenantId",
+                table: "AuditLogs",
+                column: "TenantId",
+                principalTable: "Tenants",
+                principalColumn: "Id");
+
+            migrationBuilder.AddForeignKey(
+                name: "FK_AuditLogs_Users_PerformedBy",
+                table: "AuditLogs",
+                column: "PerformedBy",
+                principalTable: "Users",
+                principalColumn: "Id",
+                onDelete: ReferentialAction.Restrict);
+        }
+    }
+}

PostFundManagement.Infrastructure/Database/Migrations/ApplicationDbContextModelSnapshot.cs

@@ -133,10 +133,6 @@ namespace PostFundManagement.Infrastructure.Database.Migrations
 
                     b.HasKey("Id");
 
-                    b.HasIndex("PerformedBy");
-
-                    b.HasIndex("TenantId");
-
                     b.ToTable("AuditLogs", (string)null);
                 });
 
@@ -1495,24 +1491,6 @@ namespace PostFundManagement.Infrastructure.Database.Migrations
                     b.Navigation("Updator");
                 });
 
-            modelBuilder.Entity("PostFundManagement.Domain.Entities.AuditLog", b =>
-                {
-                    b.HasOne("PostFundManagement.Domain.Entities.User", "Performer")
-                        .WithMany()
-                        .HasForeignKey("PerformedBy")
-                        .OnDelete(DeleteBehavior.Restrict)
-                        .IsRequired();
-
-                    b.HasOne("PostFundManagement.Domain.Entities.Tenant", "Tenant")
-                        .WithMany()
-                        .HasForeignKey("TenantId")
-                        .OnDelete(DeleteBehavior.NoAction);
-
-                    b.Navigation("Performer");
-
-                    b.Navigation("Tenant");
-                });
-
             modelBuilder.Entity("PostFundManagement.Domain.Entities.Award", b =>
                 {
                     b.HasOne("PostFundManagement.Domain.Entities.User", "Approver")