Implemented scheduling service and first two jobs

PostFundManagement.Application/Services/Communications/CommunicationsCacheService.cs

@@ -15,7 +15,7 @@ public sealed class CommunicationsCacheService(CommunicationsService service, ID
     public async Task<Result<ApplicantData[]>> GetApplicantDataAsync(Guid applicantUserId, CancellationToken cancellationToken = default) =>
         await Result.Try((Func<Task<Result<ApplicantData[]>>>)(async () =>
         {
-            if (!await featureManager.IsEnabledAsync(ServiceCachingFeature))
+            if (!await featureManager.IsEnabledAsync(FeatureServiceCaching))
                 return await service.GetApplicantDataAsync(applicantUserId, cancellationToken);
 
             var cacheKey = HashService.ToMd5Hash($"getapplicantdata-{applicantUserId}").Value;
@@ -37,7 +37,7 @@ public sealed class CommunicationsCacheService(CommunicationsService service, ID
     public async Task<Result<Invite>> GetApplicantInviteAsync(Guid applicantUserId, CancellationToken cancellationToken = default) =>
         await Result.Try((Func<Task<Result<Invite>>>)(async () =>
         {
-            if (!await featureManager.IsEnabledAsync(ServiceCachingFeature))
+            if (!await featureManager.IsEnabledAsync(FeatureServiceCaching))
                 return await service.GetApplicantInviteAsync(applicantUserId, cancellationToken);
 
             var cacheKey = HashService.ToMd5Hash($"getapplicantinvite-{applicantUserId}").Value;
@@ -59,7 +59,7 @@ public sealed class CommunicationsCacheService(CommunicationsService service, ID
     public async Task<Result<Invite[]>> GetApplicantInvitesAsync(Guid applicantUserId, CancellationToken cancellationToken = default) =>
         await Result.Try((Func<Task<Result<Invite[]>>>)(async () =>
         {
-            if (!await featureManager.IsEnabledAsync(ServiceCachingFeature))
+            if (!await featureManager.IsEnabledAsync(FeatureServiceCaching))
                 return await service.GetApplicantInvitesAsync(applicantUserId, cancellationToken);
 
             var cacheKey = HashService.ToMd5Hash($"getapplicantinvites-{applicantUserId}").Value;
@@ -83,7 +83,7 @@ public sealed class CommunicationsCacheService(CommunicationsService service, ID
     public async Task<Result<Invite[]>> GetInvitesAsync(Pagination pagination, CancellationToken cancellationToken = default) =>
         await Result.Try((Func<Task<Result<Invite[]>>>)(async () =>
         {
-            if (!await featureManager.IsEnabledAsync(ServiceCachingFeature))
+            if (!await featureManager.IsEnabledAsync(FeatureServiceCaching))
                 return await service.GetInvitesAsync(pagination, cancellationToken);
 
             var cacheKey = HashService.ToMd5Hash($"getinvites-{pagination.Page}-{pagination.PageSize}").Value;
@@ -107,7 +107,7 @@ public sealed class CommunicationsCacheService(CommunicationsService service, ID
     public async Task<Result<Notification>> GetNotificationAsync(string notificationIdHash, CancellationToken cancellationToken = default) =>
         await Result.Try((Func<Task<Result<Notification>>>)(async () =>
         {
-            if (!await featureManager.IsEnabledAsync(ServiceCachingFeature))
+            if (!await featureManager.IsEnabledAsync(FeatureServiceCaching))
                 return await service.GetNotificationAsync(notificationIdHash, cancellationToken);
 
             var cacheKey = HashService.ToMd5Hash($"getnotification-{notificationIdHash}").Value;
@@ -131,7 +131,7 @@ public sealed class CommunicationsCacheService(CommunicationsService service, ID
     public async Task<Result<Notification[]>> GetNotificationsAsync(string organisationIdHash, CancellationToken cancellationToken = default) =>
         await Result.Try((Func<Task<Result<Notification[]>>>)(async () =>
         {
-            if (!await featureManager.IsEnabledAsync(ServiceCachingFeature))
+            if (!await featureManager.IsEnabledAsync(FeatureServiceCaching))
                 return await service.GetNotificationsAsync(organisationIdHash, cancellationToken);
 
             var cacheKey = HashService.ToMd5Hash($"getnotifications-{organisationIdHash}").Value;

PostFundManagement.Application/Services/Communications/Events/SyncUserEvent.cs

@@ -1,21 +0,0 @@
-using PostFundManagement.Application.Abstractions;
-using PostFundManagement.Domain.Abstractions;
-
-namespace PostFundManagement.Application.Services.Communications.Events;
-
-public class SyncUserEvent : EventBase, IEvent
-{
-    public string Name { get; set; } = nameof(SyncUserEvent);
-
-    public static SyncUserEvent Create() => new();
-}
-
-public class SyncUserEventHandler(ILogger<SyncUserEvent> logger) : INotificationHandler<SyncUserEvent>
-{
-    public ValueTask Handle(SyncUserEvent notification, CancellationToken cancellationToken)
-    {
-        logger.LogInformation("Integration Sync executed. Correlation ID: {CorrelationId}", notification.CorrelationId);
-
-        return ValueTask.CompletedTask;
-    }
-}

PostFundManagement.Application/Services/Evidence/EvidenceCacheService.cs

@@ -21,7 +21,7 @@ public sealed class EvidenceCacheService(EvidenceService service, IDistributedCa
     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))
+            if (!await featureManager.IsEnabledAsync(FeatureServiceCaching))
                 return await service.GetEvidenceAsync(evidenceId, cancellationToken);
 
             var cacheKey = HashService.ToMd5Hash($"getevidence-{evidenceId}").Value;
@@ -45,7 +45,7 @@ public sealed class EvidenceCacheService(EvidenceService service, IDistributedCa
     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))
+            if (!await featureManager.IsEnabledAsync(FeatureServiceCaching))
                 return await service.GetEvidenceFilesAsync(pagination, cancellationToken);
 
             var cacheKey = HashService.ToMd5Hash($"getevidencefiles-{pagination.Page}-{pagination.PageSize}").Value;
@@ -69,7 +69,7 @@ public sealed class EvidenceCacheService(EvidenceService service, IDistributedCa
     public async Task<Result<string>> GetEvidenceUrlAsync(string evidenceIdHash, CancellationToken cancellationToken = default) =>
         await Result.Try((Func<Task<Result<string>>>)(async () =>
         {
-            if (!await featureManager.IsEnabledAsync(ServiceCachingFeature))
+            if (!await featureManager.IsEnabledAsync(FeatureServiceCaching))
                 return await service.GetEvidenceUrlAsync(evidenceIdHash, cancellationToken);
 
             var cacheKey = HashService.ToMd5Hash($"getevidenceurl-{evidenceIdHash}").Value;
@@ -93,7 +93,7 @@ public sealed class EvidenceCacheService(EvidenceService service, IDistributedCa
     public async Task<Result<Indicator>> GetIndicatorAsync(string indicatorId, CancellationToken cancellationToken = default) =>
         await Result.Try((Func<Task<Result<Indicator>>>)(async () =>
         {
-            if (!await featureManager.IsEnabledAsync(ServiceCachingFeature))
+            if (!await featureManager.IsEnabledAsync(FeatureServiceCaching))
                 return await service.GetIndicatorAsync(indicatorId, cancellationToken);
 
             var cacheKey = HashService.ToMd5Hash($"getindicator-{indicatorId}").Value;
@@ -117,7 +117,7 @@ public sealed class EvidenceCacheService(EvidenceService service, IDistributedCa
     public async Task<Result<Indicator[]>> GetIndicatorsAsync(Pagination pagination, CancellationToken cancellationToken = default) =>
         await Result.Try((Func<Task<Result<Indicator[]>>>)(async () =>
         {
-            if (!await featureManager.IsEnabledAsync(ServiceCachingFeature))
+            if (!await featureManager.IsEnabledAsync(FeatureServiceCaching))
                 return await service.GetIndicatorsAsync(pagination, cancellationToken);
 
             var cacheKey = HashService.ToMd5Hash($"getindicators-{pagination.Page}-{pagination.PageSize}").Value;
@@ -141,7 +141,7 @@ public sealed class EvidenceCacheService(EvidenceService service, IDistributedCa
     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))
+            if (!await featureManager.IsEnabledAsync(FeatureServiceCaching))
                 return await service.GetMilestoneEvidencesAsync(milestoneIdHash, cancellationToken);
 
             var cacheKey = HashService.ToMd5Hash($"getmilestoneevidences-{milestoneIdHash}").Value;
@@ -165,7 +165,7 @@ public sealed class EvidenceCacheService(EvidenceService service, IDistributedCa
     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))
+            if (!await featureManager.IsEnabledAsync(FeatureServiceCaching))
                 return await service.GetProjectEvidencesAsync(projectIdHash, cancellationToken);
 
             var cacheKey = HashService.ToMd5Hash($"getprojectevidences-{projectIdHash}").Value;

PostFundManagement.Application/Services/Execution/ExecutionCacheService.cs

@@ -24,7 +24,7 @@ public sealed class ExecutionCacheService(ExecutionService service, IDistributed
     public async Task<Result<Disbursement>> GetDisbursementAsync(string disbursementIdHash, CancellationToken cancellationToken = default) =>
         await Result.Try((Func<Task<Result<Disbursement>>>)(async () =>
         {
-            if (!await featureManager.IsEnabledAsync(ServiceCachingFeature))
+            if (!await featureManager.IsEnabledAsync(FeatureServiceCaching))
                 return await service.GetDisbursementAsync(disbursementIdHash, cancellationToken);
 
             var cacheKey = HashService.ToMd5Hash($"getdisbursement-{disbursementIdHash}").Value;
@@ -48,7 +48,7 @@ public sealed class ExecutionCacheService(ExecutionService service, IDistributed
     public async Task<Result<Disbursement[]>> GetDisbursementsAsync(Pagination pagination, CancellationToken cancellationToken = default) =>
         await Result.Try((Func<Task<Result<Disbursement[]>>>)(async () =>
         {
-            if (!await featureManager.IsEnabledAsync(ServiceCachingFeature))
+            if (!await featureManager.IsEnabledAsync(FeatureServiceCaching))
                 return await service.GetDisbursementsAsync(pagination, cancellationToken);
 
             var cacheKey = HashService.ToMd5Hash($"getdisbursements-{pagination.Page}-{pagination.PageSize}-{pagination.Index}").Value;
@@ -72,7 +72,7 @@ public sealed class ExecutionCacheService(ExecutionService service, IDistributed
     public async Task<Result<Risk>> GetRiskAsync(string riskIdHash, CancellationToken cancellationToken = default) =>
         await Result.Try((Func<Task<Result<Risk>>>)(async () =>
         {
-            if (!await featureManager.IsEnabledAsync(ServiceCachingFeature))
+            if (!await featureManager.IsEnabledAsync(FeatureServiceCaching))
                 return await service.GetRiskAsync(riskIdHash, cancellationToken);
 
             var cacheKey = HashService.ToMd5Hash($"getrisk-{riskIdHash}").Value;
@@ -96,7 +96,7 @@ public sealed class ExecutionCacheService(ExecutionService service, IDistributed
     public async Task<Result<Risk[]>> GetRisksAsync(Pagination pagination, CancellationToken cancellationToken = default) =>
         await Result.Try((Func<Task<Result<Risk[]>>>)(async () =>
         {
-            if (!await featureManager.IsEnabledAsync(ServiceCachingFeature))
+            if (!await featureManager.IsEnabledAsync(FeatureServiceCaching))
                 return await service.GetRisksAsync(pagination, cancellationToken);
 
             var cacheKey = HashService.ToMd5Hash($"getrisks-{pagination.Page}-{pagination.PageSize}-{pagination.Index}").Value;
@@ -120,7 +120,7 @@ public sealed class ExecutionCacheService(ExecutionService service, IDistributed
     public async Task<Result<Rule>> GetRuleAsync(string ruleIdHash, CancellationToken cancellationToken = default) =>
         await Result.Try((Func<Task<Result<Rule>>>)(async () =>
         {
-            if (!await featureManager.IsEnabledAsync(ServiceCachingFeature))
+            if (!await featureManager.IsEnabledAsync(FeatureServiceCaching))
                 return await service.GetRuleAsync(ruleIdHash, cancellationToken);
 
             var cacheKey = HashService.ToMd5Hash($"getrisk-{ruleIdHash}").Value;
@@ -144,7 +144,7 @@ public sealed class ExecutionCacheService(ExecutionService service, IDistributed
     public async Task<Result<Rule[]>> GetRulesAsync(Pagination pagination, CancellationToken cancellationToken = default) =>
         await Result.Try((Func<Task<Result<Rule[]>>>)(async () =>
         {
-            if (!await featureManager.IsEnabledAsync(ServiceCachingFeature))
+            if (!await featureManager.IsEnabledAsync(FeatureServiceCaching))
                 return await service.GetRulesAsync(pagination, cancellationToken);
 
             var cacheKey = HashService.ToMd5Hash($"getrules-{pagination.Page}-{pagination.PageSize}-{pagination.Index}").Value;

PostFundManagement.Application/Services/Governance/GovernanceCacheService.cs

@@ -27,7 +27,7 @@ public sealed class GovernanceCacheService(GovernanceService service, IDistribut
     public async Task<Result<Dashboard>> GetDashboardAsync(CancellationToken cancellationToken = default) =>
         await Result.Try((Func<Task<Result<Dashboard>>>)(async () =>
         {
-            if (!await featureManager.IsEnabledAsync(ServiceCachingFeature))
+            if (!await featureManager.IsEnabledAsync(FeatureServiceCaching))
                 return await service.GetDashboardAsync(cancellationToken);
 
             var cacheKey = HashService.ToMd5Hash($"getdashboard").Value;
@@ -51,7 +51,7 @@ public sealed class GovernanceCacheService(GovernanceService service, IDistribut
     public async Task<Result<Instrument[]>> GetInstrumentsAsync(string programmeIdHash, CancellationToken cancellationToken = default) =>
         await Result.Try((Func<Task<Result<Instrument[]>>>)(async () =>
         {
-            if (!await featureManager.IsEnabledAsync(ServiceCachingFeature))
+            if (!await featureManager.IsEnabledAsync(FeatureServiceCaching))
                 return await service.GetInstrumentsAsync(programmeIdHash, cancellationToken);
 
             var cacheKey = HashService.ToMd5Hash($"getinstruments").Value;
@@ -75,7 +75,7 @@ public sealed class GovernanceCacheService(GovernanceService service, IDistribut
     public async Task<Result<Organisation>> GetOrganisationAsync(string organisationIdHash, CancellationToken cancellationToken = default) =>
         await Result.Try((Func<Task<Result<Organisation>>>)(async () =>
         {
-            if (!await featureManager.IsEnabledAsync(ServiceCachingFeature))
+            if (!await featureManager.IsEnabledAsync(FeatureServiceCaching))
                 return await service.GetOrganisationAsync(organisationIdHash, cancellationToken);
 
             var cacheKey = HashService.ToMd5Hash($"getorganisation-{organisationIdHash}").Value;
@@ -99,7 +99,7 @@ public sealed class GovernanceCacheService(GovernanceService service, IDistribut
     public async Task<Result<Organisation[]>> GetOrganisationsAsync(Pagination pagination, CancellationToken cancellationToken = default) =>
         await Result.Try((Func<Task<Result<Organisation[]>>>)(async () =>
         {
-            if (!await featureManager.IsEnabledAsync(ServiceCachingFeature))
+            if (!await featureManager.IsEnabledAsync(FeatureServiceCaching))
                 return await service.GetOrganisationsAsync(pagination, cancellationToken);
 
             var cacheKey = HashService.ToMd5Hash($"getorganisations-{pagination.Page}-{pagination.PageSize}").Value;
@@ -123,7 +123,7 @@ public sealed class GovernanceCacheService(GovernanceService service, IDistribut
     public async Task<Result<Portfolio[]>> GetOrganisationPorfoliosAsync(string organisationIdHash, CancellationToken cancellationToken = default) =>
         await Result.Try((Func<Task<Result<Portfolio[]>>>)(async () =>
         {
-            if (!await featureManager.IsEnabledAsync(ServiceCachingFeature))
+            if (!await featureManager.IsEnabledAsync(FeatureServiceCaching))
                 return await service.GetOrganisationPorfoliosAsync(organisationIdHash, cancellationToken);
 
             var cacheKey = HashService.ToMd5Hash($"getorganisationportfolios-{organisationIdHash}").Value;
@@ -147,7 +147,7 @@ public sealed class GovernanceCacheService(GovernanceService service, IDistribut
     public async Task<Result<Portfolio>> GetPortfolioAsync(string portfolioIdHash, CancellationToken cancellationToken = default) =>
         await Result.Try((Func<Task<Result<Portfolio>>>)(async () =>
         {
-            if (!await featureManager.IsEnabledAsync(ServiceCachingFeature))
+            if (!await featureManager.IsEnabledAsync(FeatureServiceCaching))
                 return await service.GetPortfolioAsync(portfolioIdHash, cancellationToken);
 
             var cacheKey = HashService.ToMd5Hash($"getportfolio-{portfolioIdHash}").Value;
@@ -171,7 +171,7 @@ public sealed class GovernanceCacheService(GovernanceService service, IDistribut
     public async Task<Result<Programme[]>> GetPortfolioProgrammesAsync(string portfolioIdHash, CancellationToken cancellationToken = default) =>
         await Result.Try((Func<Task<Result<Programme[]>>>)(async () =>
         {
-            if (!await featureManager.IsEnabledAsync(ServiceCachingFeature))
+            if (!await featureManager.IsEnabledAsync(FeatureServiceCaching))
                 return await service.GetPortfolioProgrammesAsync(portfolioIdHash, cancellationToken);
 
             var cacheKey = HashService.ToMd5Hash($"getportfolioprogrammes-{portfolioIdHash}").Value;
@@ -195,7 +195,7 @@ public sealed class GovernanceCacheService(GovernanceService service, IDistribut
     public async Task<Result<Programme[]>> GetProgrammesAsync(string portfolioIdHash, CancellationToken cancellationToken = default) =>
         await Result.Try((Func<Task<Result<Programme[]>>>)(async () =>
         {
-            if (!await featureManager.IsEnabledAsync(ServiceCachingFeature))
+            if (!await featureManager.IsEnabledAsync(FeatureServiceCaching))
                 return await service.GetProgrammesAsync(portfolioIdHash, cancellationToken);
 
             var cacheKey = HashService.ToMd5Hash($"getprogrammes-{portfolioIdHash}").Value;
@@ -219,7 +219,7 @@ public sealed class GovernanceCacheService(GovernanceService service, IDistribut
     public async Task<Result<Tenant>> GetTenantAsync(string tenantIdHash, CancellationToken cancellationToken = default) =>
         await Result.Try((Func<Task<Result<Tenant>>>)(async () =>
         {
-            if (!await featureManager.IsEnabledAsync(ServiceCachingFeature))
+            if (!await featureManager.IsEnabledAsync(FeatureServiceCaching))
                 return await service.GetTenantAsync(tenantIdHash, cancellationToken);
 
             var cacheKey = HashService.ToMd5Hash($"gettenant-{tenantIdHash}").Value;
@@ -243,7 +243,7 @@ public sealed class GovernanceCacheService(GovernanceService service, IDistribut
     public async Task<Result<TenantOrganisation>> GetTenantOrganisationAsync(string tenantOrganisationIdHash, CancellationToken cancellationToken = default) =>
         await Result.Try((Func<Task<Result<TenantOrganisation>>>)(async () =>
         {
-            if (!await featureManager.IsEnabledAsync(ServiceCachingFeature))
+            if (!await featureManager.IsEnabledAsync(FeatureServiceCaching))
                 return await service.GetTenantOrganisationAsync(tenantOrganisationIdHash, cancellationToken);
 
             var cacheKey = HashService.ToMd5Hash($"gettenantorganisation-{tenantOrganisationIdHash}").Value;
@@ -267,7 +267,7 @@ public sealed class GovernanceCacheService(GovernanceService service, IDistribut
     public async Task<Result<TenantOrganisation[]>> GetTenantOrganisationsAsync(string tenantIdHash, CancellationToken cancellationToken = default) =>
         await Result.Try((Func<Task<Result<TenantOrganisation[]>>>)(async () =>
         {
-            if (!await featureManager.IsEnabledAsync(ServiceCachingFeature))
+            if (!await featureManager.IsEnabledAsync(FeatureServiceCaching))
                 return await service.GetTenantOrganisationsAsync(tenantIdHash, cancellationToken);
 
             var cacheKey = HashService.ToMd5Hash($"gettenantorganisations-{tenantIdHash}").Value;
@@ -294,7 +294,7 @@ public sealed class GovernanceCacheService(GovernanceService service, IDistribut
     public async Task<Result<Tenant[]>> GetTenantsAsync(CancellationToken cancellationToken = default) =>
         await Result.Try((Func<Task<Result<Tenant[]>>>)(async () =>
         {
-            if (!await featureManager.IsEnabledAsync(ServiceCachingFeature))
+            if (!await featureManager.IsEnabledAsync(FeatureServiceCaching))
                 return await service.GetTenantsAsync(cancellationToken);
 
             var cacheKey = HashService.ToMd5Hash($"gettenants").Value;
@@ -336,7 +336,7 @@ public sealed class GovernanceCacheService(GovernanceService service, IDistribut
     public async Task<Result<Portfolio[]>> GetPorfoliosAsync(Pagination pagination, CancellationToken cancellationToken = default) =>
         await Result.Try((Func<Task<Result<Portfolio[]>>>)(async () =>
         {
-            if (!await featureManager.IsEnabledAsync(ServiceCachingFeature))
+            if (!await featureManager.IsEnabledAsync(FeatureServiceCaching))
                 return await service.GetPorfoliosAsync(pagination, cancellationToken);
 
             var cacheKey = HashService.ToMd5Hash($"getportfolios-{pagination.Page}-{pagination.PageSize}").Value;
@@ -360,7 +360,7 @@ public sealed class GovernanceCacheService(GovernanceService service, IDistribut
     public async Task<Result<decimal>> GetProgrammeValueAsync(string programmeIdHash, CancellationToken cancellationToken = default) =>
         await Result.Try((Func<Task<Result<decimal>>>)(async () =>
         {
-            if (!await featureManager.IsEnabledAsync(ServiceCachingFeature))
+            if (!await featureManager.IsEnabledAsync(FeatureServiceCaching))
                 return await service.GetProgrammeValueAsync(programmeIdHash, cancellationToken);
 
             var cacheKey = HashService.ToMd5Hash($"getprogrammevalue-{programmeIdHash}").Value;
@@ -386,7 +386,7 @@ public sealed class GovernanceCacheService(GovernanceService service, IDistribut
     public async Task<Result<decimal>> GetPorfolioValueAsync(string portfolioIdHash, CancellationToken cancellationToken = default) =>
         await Result.Try((Func<Task<Result<decimal>>>)(async () =>
         {
-            if (!await featureManager.IsEnabledAsync(ServiceCachingFeature))
+            if (!await featureManager.IsEnabledAsync(FeatureServiceCaching))
                 return await service.GetPorfolioValueAsync(portfolioIdHash, cancellationToken);
 
             var cacheKey = HashService.ToMd5Hash($"getportfoliovalue-{portfolioIdHash}").Value;

PostFundManagement.Application/Services/Grants/GrantsCacheService.cs

@@ -27,7 +27,7 @@ public sealed class GrantsCacheService(GrantsService service, IDistributedCache
     public async Task<Result<Award>> GetAwardAsync(string awardIdHash, CancellationToken cancellationToken = default) =>
         await Result.Try((Func<Task<Result<Award>>>)(async () =>
         {
-            if (!await featureManager.IsEnabledAsync(ServiceCachingFeature))
+            if (!await featureManager.IsEnabledAsync(FeatureServiceCaching))
                 return await service.GetAwardAsync(awardIdHash, cancellationToken);
 
             var cacheKey = HashService.ToMd5Hash($"getaward-{awardIdHash}").Value;
@@ -51,7 +51,7 @@ public sealed class GrantsCacheService(GrantsService service, IDistributedCache
     public async Task<Result<Award[]>> GetAwardsAsync(Pagination pagination, CancellationToken cancellationToken = default) =>
         await Result.Try((Func<Task<Result<Award[]>>>)(async () =>
         {
-            if (!await featureManager.IsEnabledAsync(ServiceCachingFeature))
+            if (!await featureManager.IsEnabledAsync(FeatureServiceCaching))
                 return await service.GetAwardsAsync(pagination, cancellationToken);
 
             var cacheKey = HashService.ToMd5Hash($"getawards-{pagination.Page}-{pagination.PageSize}-{pagination.Index}").Value;
@@ -75,7 +75,7 @@ public sealed class GrantsCacheService(GrantsService service, IDistributedCache
     public async Task<Result<Budget>> GetBudgetAsync(string budgetIdHash, CancellationToken cancellationToken = default) =>
         await Result.Try((Func<Task<Result<Budget>>>)(async () =>
         {
-            if (!await featureManager.IsEnabledAsync(ServiceCachingFeature))
+            if (!await featureManager.IsEnabledAsync(FeatureServiceCaching))
                 return await service.GetBudgetAsync(budgetIdHash, cancellationToken);
 
             var cacheKey = HashService.ToMd5Hash($"getbudget-{budgetIdHash}").Value;
@@ -99,7 +99,7 @@ public sealed class GrantsCacheService(GrantsService service, IDistributedCache
     public async Task<Result<Budget[]>> GetBudgetsAsync(Pagination pagination, CancellationToken cancellationToken = default) =>
         await Result.Try((Func<Task<Result<Budget[]>>>)(async () =>
         {
-            if (!await featureManager.IsEnabledAsync(ServiceCachingFeature))
+            if (!await featureManager.IsEnabledAsync(FeatureServiceCaching))
                 return await service.GetBudgetsAsync(pagination, cancellationToken);
 
             var cacheKey = HashService.ToMd5Hash($"getbudgets-{pagination.Page}-{pagination.PageSize}-{pagination.Index}").Value;
@@ -123,7 +123,7 @@ public sealed class GrantsCacheService(GrantsService service, IDistributedCache
     public async Task<Result<Contract>> GetContractAsync(string contractIdHash, CancellationToken cancellationToken = default) =>
         await Result.Try((Func<Task<Result<Contract>>>)(async () =>
         {
-            if (!await featureManager.IsEnabledAsync(ServiceCachingFeature))
+            if (!await featureManager.IsEnabledAsync(FeatureServiceCaching))
                 return await service.GetContractAsync(contractIdHash, cancellationToken);
 
             var cacheKey = HashService.ToMd5Hash($"getctract-{contractIdHash}").Value;
@@ -147,7 +147,7 @@ public sealed class GrantsCacheService(GrantsService service, IDistributedCache
     public async Task<Result<Contract[]>> GetContractsAsync(Pagination pagination, CancellationToken cancellationToken = default) =>
         await Result.Try((Func<Task<Result<Contract[]>>>)(async () =>
         {
-            if (!await featureManager.IsEnabledAsync(ServiceCachingFeature))
+            if (!await featureManager.IsEnabledAsync(FeatureServiceCaching))
                 return await service.GetContractsAsync(pagination, cancellationToken);
 
             var cacheKey = HashService.ToMd5Hash($"getcontracts-{pagination.Index}-{pagination.PageSize}-{pagination.Page}").Value;
@@ -171,7 +171,7 @@ public sealed class GrantsCacheService(GrantsService service, IDistributedCache
     public async Task<Result<string>> GetContractUrlAsync(string contractIdHash, CancellationToken cancellationToken = default) =>
         await Result.Try((Func<Task<Result<string>>>)(async () =>
         {
-            if (!await featureManager.IsEnabledAsync(ServiceCachingFeature))
+            if (!await featureManager.IsEnabledAsync(FeatureServiceCaching))
                 return await service.GetContractUrlAsync(contractIdHash, cancellationToken);
 
             var cacheKey = HashService.ToMd5Hash($"getcontracturl-{contractIdHash}").Value;

PostFundManagement.Application/Services/Projects/ProjectCacheService.cs

@@ -42,7 +42,7 @@ public sealed class ProjectCacheService(ProjectService service, IDistributedCach
     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))
+            if (!await featureManager.IsEnabledAsync(FeatureServiceCaching))
                 return await service.GetActivitiesAsync(projectIdHash, cancellationToken);
 
             var cacheKey = HashService.ToMd5Hash($"getactivities-{projectIdHash}").Value;
@@ -66,7 +66,7 @@ public sealed class ProjectCacheService(ProjectService service, IDistributedCach
     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))
+            if (!await featureManager.IsEnabledAsync(FeatureServiceCaching))
                 return await service.GetActivityAsync(activityIdHash, cancellationToken);
 
             var cacheKey = HashService.ToMd5Hash($"getactivity-{activityIdHash}").Value;
@@ -90,7 +90,7 @@ public sealed class ProjectCacheService(ProjectService service, IDistributedCach
     public async Task<Result<Beneficiary[]>> GetBeneficiariesAsync(string projectIdHash, CancellationToken cancellationToken = default) =>
         await Result.Try((Func<Task<Result<Beneficiary[]>>>)(async () =>
         {
-            if (!await featureManager.IsEnabledAsync(ServiceCachingFeature))
+            if (!await featureManager.IsEnabledAsync(FeatureServiceCaching))
                 return await service.GetBeneficiariesAsync(projectIdHash, cancellationToken);
 
             var cacheKey = HashService.ToMd5Hash($"getbeneficiaries-{projectIdHash}").Value;
@@ -114,7 +114,7 @@ public sealed class ProjectCacheService(ProjectService service, IDistributedCach
     public async Task<Result<Beneficiary>> GetBeneficiaryAsync(string beneficiaryIdHash, CancellationToken cancellationToken = default) =>
         await Result.Try((Func<Task<Result<Beneficiary>>>)(async () =>
         {
-            if (!await featureManager.IsEnabledAsync(ServiceCachingFeature))
+            if (!await featureManager.IsEnabledAsync(FeatureServiceCaching))
                 return await service.GetBeneficiaryAsync(beneficiaryIdHash, cancellationToken);
 
             var cacheKey = HashService.ToMd5Hash($"getbeneficiary-{beneficiaryIdHash}").Value;
@@ -138,7 +138,7 @@ public sealed class ProjectCacheService(ProjectService service, IDistributedCach
     public async Task<Result<ChangeRequest>> GetChangeRequestAsync(string changeRequestIdHash, CancellationToken cancellationToken = default) =>
         await Result.Try((Func<Task<Result<ChangeRequest>>>)(async () =>
         {
-            if (!await featureManager.IsEnabledAsync(ServiceCachingFeature))
+            if (!await featureManager.IsEnabledAsync(FeatureServiceCaching))
                 return await service.GetChangeRequestAsync(changeRequestIdHash, cancellationToken);
 
             var cacheKey = HashService.ToMd5Hash($"getchangerequest-{changeRequestIdHash}").Value;
@@ -162,7 +162,7 @@ public sealed class ProjectCacheService(ProjectService service, IDistributedCach
     public async Task<Result<ChangeRequest[]>> GetChangeRequestsAsync(string projectIdHash, CancellationToken cancellationToken = default) =>
         await Result.Try((Func<Task<Result<ChangeRequest[]>>>)(async () =>
         {
-            if (!await featureManager.IsEnabledAsync(ServiceCachingFeature))
+            if (!await featureManager.IsEnabledAsync(FeatureServiceCaching))
                 return await service.GetChangeRequestsAsync(projectIdHash, cancellationToken);
 
             var cacheKey = HashService.ToMd5Hash($"getchangerequests-{projectIdHash}").Value;
@@ -186,7 +186,7 @@ public sealed class ProjectCacheService(ProjectService service, IDistributedCach
     public async Task<Result<ComplianceItem>> GetComplianceItemAsync(string complianceItemIdHash, CancellationToken cancellationToken = default) =>
         await Result.Try((Func<Task<Result<ComplianceItem>>>)(async () =>
         {
-            if (!await featureManager.IsEnabledAsync(ServiceCachingFeature))
+            if (!await featureManager.IsEnabledAsync(FeatureServiceCaching))
                 return await service.GetComplianceItemAsync(complianceItemIdHash, cancellationToken);
 
             var cacheKey = HashService.ToMd5Hash($"getcomplianceitem-{complianceItemIdHash}").Value;
@@ -210,7 +210,7 @@ public sealed class ProjectCacheService(ProjectService service, IDistributedCach
     public async Task<Result<ComplianceItem[]>> GetComplianceItemsAsync(string projectIdHash, CancellationToken cancellationToken = default) =>
         await Result.Try((Func<Task<Result<ComplianceItem[]>>>)(async () =>
         {
-            if (!await featureManager.IsEnabledAsync(ServiceCachingFeature))
+            if (!await featureManager.IsEnabledAsync(FeatureServiceCaching))
                 return await service.GetComplianceItemsAsync(projectIdHash, cancellationToken);
 
             var cacheKey = HashService.ToMd5Hash($"getcomplianceitems-{projectIdHash}").Value;
@@ -234,7 +234,7 @@ public sealed class ProjectCacheService(ProjectService service, IDistributedCach
     public async Task<Result<Issue>> GetIssueAsync(string issueIdHash, CancellationToken cancellationToken = default) =>
         await Result.Try((Func<Task<Result<Issue>>>)(async () =>
         {
-            if (!await featureManager.IsEnabledAsync(ServiceCachingFeature))
+            if (!await featureManager.IsEnabledAsync(FeatureServiceCaching))
                 return await service.GetIssueAsync(issueIdHash, cancellationToken);
 
             var cacheKey = HashService.ToMd5Hash($"getissue-{issueIdHash}").Value;
@@ -258,7 +258,7 @@ public sealed class ProjectCacheService(ProjectService service, IDistributedCach
     public async Task<Result<Issue[]>> GetIssuesAsync(string projectIdHash, CancellationToken cancellationToken = default) =>
         await Result.Try((Func<Task<Result<Issue[]>>>)(async () =>
         {
-            if (!await featureManager.IsEnabledAsync(ServiceCachingFeature))
+            if (!await featureManager.IsEnabledAsync(FeatureServiceCaching))
                 return await service.GetIssuesAsync(projectIdHash, cancellationToken);
 
             var cacheKey = HashService.ToMd5Hash($"getissues-{projectIdHash}").Value;
@@ -282,7 +282,7 @@ public sealed class ProjectCacheService(ProjectService service, IDistributedCach
     public async Task<Result<Milestone>> GetMilestoneAsync(string milestoneIdHash, CancellationToken cancellationToken = default) =>
         await Result.Try((Func<Task<Result<Milestone>>>)(async () =>
         {
-            if (!await featureManager.IsEnabledAsync(ServiceCachingFeature))
+            if (!await featureManager.IsEnabledAsync(FeatureServiceCaching))
                 return await service.GetMilestoneAsync(milestoneIdHash, cancellationToken);
 
             var cacheKey = HashService.ToMd5Hash($"getmilestone-{milestoneIdHash}").Value;
@@ -306,7 +306,7 @@ public sealed class ProjectCacheService(ProjectService service, IDistributedCach
     public async Task<Result<Milestone[]>> GetMilestonesAsync(Pagination pagination, CancellationToken cancellationToken = default) =>
         await Result.Try((Func<Task<Result<Milestone[]>>>)(async () =>
         {
-            if (!await featureManager.IsEnabledAsync(ServiceCachingFeature))
+            if (!await featureManager.IsEnabledAsync(FeatureServiceCaching))
                 return await service.GetMilestonesAsync(pagination, cancellationToken);
 
             var cacheKey = HashService.ToMd5Hash($"getmilestones-{pagination.Index}-{pagination.PageSize}-{pagination.Page}").Value;
@@ -330,7 +330,7 @@ public sealed class ProjectCacheService(ProjectService service, IDistributedCach
     public async Task<Result<Outcome>> GetOutcomeAsync(string outcomeIdHash, CancellationToken cancellationToken = default) =>
         await Result.Try((Func<Task<Result<Outcome>>>)(async () =>
         {
-            if (!await featureManager.IsEnabledAsync(ServiceCachingFeature))
+            if (!await featureManager.IsEnabledAsync(FeatureServiceCaching))
                 return await service.GetOutcomeAsync(outcomeIdHash, cancellationToken);
 
             var cacheKey = HashService.ToMd5Hash($"getoutcome-{outcomeIdHash}").Value;
@@ -354,7 +354,7 @@ public sealed class ProjectCacheService(ProjectService service, IDistributedCach
     public async Task<Result<Outcome[]>> GetOutcomesAsync(string beneficiaryIdHash, CancellationToken cancellationToken = default) =>
         await Result.Try((Func<Task<Result<Outcome[]>>>)(async () =>
         {
-            if (!await featureManager.IsEnabledAsync(ServiceCachingFeature))
+            if (!await featureManager.IsEnabledAsync(FeatureServiceCaching))
                 return await service.GetOutcomesAsync(beneficiaryIdHash, cancellationToken);
 
             var cacheKey = HashService.ToMd5Hash($"getoutcomes-{beneficiaryIdHash}").Value;
@@ -378,7 +378,7 @@ public sealed class ProjectCacheService(ProjectService service, IDistributedCach
     public async Task<Result<Outcome[]>> GetProjectOutcomesAsync(string projectIdHash, CancellationToken cancellationToken = default) =>
         await Result.Try((Func<Task<Result<Outcome[]>>>)(async () =>
         {
-            if (!await featureManager.IsEnabledAsync(ServiceCachingFeature))
+            if (!await featureManager.IsEnabledAsync(FeatureServiceCaching))
                 return await service.GetProjectOutcomesAsync(projectIdHash, cancellationToken);
 
             var cacheKey = HashService.ToMd5Hash($"getprojectoutcomes-{projectIdHash}").Value;
@@ -402,7 +402,7 @@ public sealed class ProjectCacheService(ProjectService service, IDistributedCach
     public async Task<Result<Programme>> GetProgrammeAsync(string programmeIdHash, CancellationToken cancellationToken = default) =>
         await Result.Try((Func<Task<Result<Programme>>>)(async () =>
         {
-            if (!await featureManager.IsEnabledAsync(ServiceCachingFeature))
+            if (!await featureManager.IsEnabledAsync(FeatureServiceCaching))
                 return await service.GetProgrammeAsync(programmeIdHash, cancellationToken);
 
             var cacheKey = HashService.ToMd5Hash($"getprogramme-{programmeIdHash}").Value;
@@ -426,7 +426,7 @@ public sealed class ProjectCacheService(ProjectService service, IDistributedCach
     public async Task<Result<Project[]>> GetProgrammeProjectsAsync(string programmeIdHash, CancellationToken cancellationToken = default) =>
         await Result.Try((Func<Task<Result<Project[]>>>)(async () =>
         {
-            if (!await featureManager.IsEnabledAsync(ServiceCachingFeature))
+            if (!await featureManager.IsEnabledAsync(FeatureServiceCaching))
                 return await service.GetProgrammeProjectsAsync(programmeIdHash, cancellationToken);
 
             var cacheKey = HashService.ToMd5Hash($"getprogrammeprojects-{programmeIdHash}").Value;
@@ -450,7 +450,7 @@ public sealed class ProjectCacheService(ProjectService service, IDistributedCach
     public async Task<Result<Programme[]>> GetProgrammesAsync(Pagination pagination, CancellationToken cancellationToken = default) =>
         await Result.Try((Func<Task<Result<Programme[]>>>)(async () =>
         {
-            if (!await featureManager.IsEnabledAsync(ServiceCachingFeature))
+            if (!await featureManager.IsEnabledAsync(FeatureServiceCaching))
                 return await service.GetProgrammesAsync(pagination, cancellationToken);
 
             var cacheKey = HashService.ToMd5Hash($"getprogrammes-{pagination.Index}-{pagination.PageSize}-{pagination.Page}").Value;
@@ -474,7 +474,7 @@ public sealed class ProjectCacheService(ProjectService service, IDistributedCach
     public async Task<Result<Project>> GetProjectAsync(string projectIdHash, CancellationToken cancellationToken = default) =>
         await Result.Try((Func<Task<Result<Project>>>)(async () =>
         {
-            if (!await featureManager.IsEnabledAsync(ServiceCachingFeature))
+            if (!await featureManager.IsEnabledAsync(FeatureServiceCaching))
                 return await service.GetProjectAsync(projectIdHash, cancellationToken);
 
             var cacheKey = HashService.ToMd5Hash($"getproject-{projectIdHash}").Value;
@@ -498,7 +498,7 @@ public sealed class ProjectCacheService(ProjectService service, IDistributedCach
     public async Task<Result<Indicator[]>> GetProjectIndicatorsAsync(string projectIdHash, CancellationToken cancellationToken = default) =>
         await Result.Try((Func<Task<Result<Indicator[]>>>)(async () =>
         {
-            if (!await featureManager.IsEnabledAsync(ServiceCachingFeature))
+            if (!await featureManager.IsEnabledAsync(FeatureServiceCaching))
                 return await service.GetProjectIndicatorsAsync(projectIdHash, cancellationToken);
 
             var cacheKey = HashService.ToMd5Hash($"getprojectindicators-{projectIdHash}").Value;
@@ -522,7 +522,7 @@ public sealed class ProjectCacheService(ProjectService service, IDistributedCach
     public async Task<Result<Milestone[]>> GetProjectMilestonesAsync(string projectIdHash, CancellationToken cancellationToken = default) =>
         await Result.Try((Func<Task<Result<Milestone[]>>>)(async () =>
         {
-            if (!await featureManager.IsEnabledAsync(ServiceCachingFeature))
+            if (!await featureManager.IsEnabledAsync(FeatureServiceCaching))
                 return await service.GetProjectMilestonesAsync(projectIdHash, cancellationToken);
 
             var cacheKey = HashService.ToMd5Hash($"getprojectmilestones-{projectIdHash}").Value;
@@ -546,7 +546,7 @@ public sealed class ProjectCacheService(ProjectService service, IDistributedCach
     public async Task<Result<Risk[]>> GetProjectRisksAsync(string projectIdHash, CancellationToken cancellationToken = default) =>
         await Result.Try((Func<Task<Result<Risk[]>>>)(async () =>
         {
-            if (!await featureManager.IsEnabledAsync(ServiceCachingFeature))
+            if (!await featureManager.IsEnabledAsync(FeatureServiceCaching))
                 return await service.GetProjectRisksAsync(projectIdHash, cancellationToken);
 
             var cacheKey = HashService.ToMd5Hash($"getprojectrisks-{projectIdHash}").Value;
@@ -570,7 +570,7 @@ public sealed class ProjectCacheService(ProjectService service, IDistributedCach
     public async Task<Result<Project[]>> GetProjectsAsync(Pagination pagination, CancellationToken cancellationToken = default) =>
         await Result.Try((Func<Task<Result<Project[]>>>)(async () =>
         {
-            if (!await featureManager.IsEnabledAsync(ServiceCachingFeature))
+            if (!await featureManager.IsEnabledAsync(FeatureServiceCaching))
                 return await service.GetProjectsAsync(pagination, cancellationToken);
 
             var cacheKey = HashService.ToMd5Hash($"getprojects-{pagination.Index}-{pagination.Page}-{pagination.PageSize}").Value;
@@ -594,7 +594,7 @@ public sealed class ProjectCacheService(ProjectService service, IDistributedCach
     public async Task<Result<SiteVisit>> GetSiteVisitAsync(string siteVisitIdHash, CancellationToken cancellationToken = default) =>
         await Result.Try((Func<Task<Result<SiteVisit>>>)(async () =>
         {
-            if (!await featureManager.IsEnabledAsync(ServiceCachingFeature))
+            if (!await featureManager.IsEnabledAsync(FeatureServiceCaching))
                 return await service.GetSiteVisitAsync(siteVisitIdHash, cancellationToken);
 
             var cacheKey = HashService.ToMd5Hash($"getsitevisit-{siteVisitIdHash}").Value;
@@ -618,7 +618,7 @@ public sealed class ProjectCacheService(ProjectService service, IDistributedCach
     public async Task<Result<SiteVisit[]>> GetSiteVisitsAsync(string projectIdHash, CancellationToken cancellationToken = default) =>
         await Result.Try((Func<Task<Result<SiteVisit[]>>>)(async () =>
         {
-            if (!await featureManager.IsEnabledAsync(ServiceCachingFeature))
+            if (!await featureManager.IsEnabledAsync(FeatureServiceCaching))
                 return await service.GetSiteVisitsAsync(projectIdHash, cancellationToken);
 
             var cacheKey = HashService.ToMd5Hash($"getsitevisits-{projectIdHash}").Value;

PostFundManagement.Application/Services/Users/UserCacheService.cs

@@ -29,7 +29,7 @@ public sealed class UserCacheService(UserService service, IDistributedCache cach
     public async Task<Result<Claim[]>> GetRoleClaimsAsync(Guid roleId, Guid userId, CancellationToken cancellationToken = default) =>
         await Result.Try((Func<Task<Result<Claim[]>>>)(async () =>
         {
-            if (!await featureManager.IsEnabledAsync(ServiceCachingFeature))
+            if (!await featureManager.IsEnabledAsync(FeatureServiceCaching))
                 return await service.GetRoleClaimsAsync(roleId, userId, cancellationToken);
 
             var cacheKey = HashService.ToMd5Hash($"getsystemroles-{userId}").Value;
@@ -54,7 +54,7 @@ public sealed class UserCacheService(UserService service, IDistributedCache cach
     public async Task<Result<Role[]>> GetSystemRolesAsync(Guid userId, CancellationToken cancellationToken = default) =>
         await Result.Try((Func<Task<Result<Role[]>>>)(async () =>
         {
-            if (!await featureManager.IsEnabledAsync(ServiceCachingFeature))
+            if (!await featureManager.IsEnabledAsync(FeatureServiceCaching))
                 return await service.GetSystemRolesAsync(userId, cancellationToken);
 
             var cacheKey = HashService.ToMd5Hash($"getsystemroles-{userId}").Value;
@@ -79,7 +79,7 @@ public sealed class UserCacheService(UserService service, IDistributedCache cach
     public async Task<Result<User>> GetUserAsync(Guid userId, CancellationToken cancellationToken) =>
         await Result.Try((Func<Task<Result<User>>>)(async () =>
         {
-            if (!await featureManager.IsEnabledAsync(ServiceCachingFeature))
+            if (!await featureManager.IsEnabledAsync(FeatureServiceCaching))
                 return await service.GetUserAsync(userId, cancellationToken);
 
             var cacheKey = HashService.ToMd5Hash($"getuser-{userId}").Value;
@@ -103,7 +103,7 @@ public sealed class UserCacheService(UserService service, IDistributedCache cach
     public async Task<Result<Claim[]>> GetUserClaimsAsync(Guid targetUserId, Guid userId, CancellationToken cancellationToken = default) =>
         await Result.Try((Func<Task<Result<Claim[]>>>)(async () =>
         {
-            if (!await featureManager.IsEnabledAsync(ServiceCachingFeature))
+            if (!await featureManager.IsEnabledAsync(FeatureServiceCaching))
                 return await service.GetUserClaimsAsync(targetUserId, userId, cancellationToken);
 
             var cacheKey = HashService.ToMd5Hash($"getuserclaims-{userId}").Value;
@@ -128,7 +128,7 @@ public sealed class UserCacheService(UserService service, IDistributedCache cach
     public async Task<Result<Role[]>> GetUserRolesAsync(Guid targetUserId, Guid userId, CancellationToken cancellationToken = default) =>
         await Result.Try((Func<Task<Result<Role[]>>>)(async () =>
         {
-            if (!await featureManager.IsEnabledAsync(ServiceCachingFeature))
+            if (!await featureManager.IsEnabledAsync(FeatureServiceCaching))
                 return await service.GetUserRolesAsync(targetUserId, userId, cancellationToken);
 
             var cacheKey = HashService.ToMd5Hash($"getuserroles-{userId}").Value;