647 lines
29 KiB
C#
647 lines
29 KiB
C#
using PostFundManagement.Application.Abstractions;
|
|
using PostFundManagement.Application.Abstractions.Services;
|
|
using PostFundManagement.Application.Extensions;
|
|
using PostFundManagement.Application.Services.Shared;
|
|
using PostFundManagement.Domain;
|
|
using PostFundManagement.Domain.Models;
|
|
using static PostFundManagement.Domain.Extensions.Constants;
|
|
|
|
namespace PostFundManagement.Application.Services.Projects;
|
|
|
|
public sealed class ProjectCacheService(ProjectService service, IDistributedCache cache,
|
|
IFeatureManager featureManager) : ServiceCacheBase, IProjectService
|
|
{
|
|
public async Task<Result> CreateActivityAsync(CreateActivityRequest request, Guid userId, CancellationToken cancellationToken = default) =>
|
|
await service.CreateActivityAsync(request, userId, cancellationToken);
|
|
|
|
public async Task<Result> CreateBeneficiaryAsync(CreateBeneficiaryRequest request, Guid userId, CancellationToken cancellationToken = default) =>
|
|
await service.CreateBeneficiaryAsync(request, userId, cancellationToken);
|
|
|
|
public async Task<Result> CreateChangeRequestAsync(CreateChangeRequest request, Guid userId, CancellationToken cancellationToken = default) =>
|
|
await service.CreateChangeRequestAsync(request, userId, cancellationToken);
|
|
|
|
public async Task<Result> CreateComplianceItemAsync(CreateComplianceItemRequest request, Guid userId, CancellationToken cancellationToken = default) =>
|
|
await service.CreateComplianceItemAsync(request, userId, cancellationToken);
|
|
|
|
public async Task<Result> CreateIssueAsync(CreateIssueRequest request, Guid userId, CancellationToken cancellationToken = default) =>
|
|
await service.CreateIssueAsync(request, userId, cancellationToken);
|
|
|
|
public async Task<Result> CreateOutcomeAsync(CreateOutcomeRequest request, Guid userId, CancellationToken cancellationToken = default) =>
|
|
await service.CreateOutcomeAsync(request, userId, cancellationToken);
|
|
|
|
public async Task<Result> CreateProgrammeAsync(CreateProgrammeRequest request, Guid userId, CancellationToken cancellationToken = default) =>
|
|
await service.CreateProgrammeAsync(request, userId, cancellationToken);
|
|
|
|
public async Task<Result> CreateProjectAsync(CreateProjectRequest request, Guid userId, CancellationToken cancellationToken = default) =>
|
|
await service.CreateProjectAsync(request, userId, cancellationToken);
|
|
|
|
public async Task<Result> CreateSiteVisitAsync(CreateSiteVisitRequest request, Guid userId, CancellationToken cancellationToken = default) =>
|
|
await service.CreateSiteVisitAsync(request, userId, cancellationToken);
|
|
|
|
public async Task<Result<Domain.Models.Activity[]>> GetActivitiesAsync(string projectIdHash, CancellationToken cancellationToken = default) =>
|
|
await Result.Try((Func<Task<Result<Domain.Models.Activity[]>>>)(async () =>
|
|
{
|
|
if (!await featureManager.IsEnabledAsync(ServiceCachingFeature))
|
|
return await service.GetActivitiesAsync(projectIdHash, cancellationToken);
|
|
|
|
var cacheKey = HashService.ToMd5Hash($"getactivities-{projectIdHash}").Value;
|
|
|
|
var cached = await cache.GetStringAsync(cacheKey, cancellationToken);
|
|
|
|
if (string.IsNullOrWhiteSpace(cached))
|
|
{
|
|
var result = await service.GetActivitiesAsync(projectIdHash, cancellationToken);
|
|
|
|
if (result.IsFailed) return result;
|
|
|
|
await cache.SetStringAsync(cacheKey, result.Value.ToJson(), cacheOptions, cancellationToken);
|
|
|
|
return result.Value;
|
|
}
|
|
|
|
return Result.Ok(cached.FromJson<Domain.Models.Activity[]>());
|
|
}));
|
|
|
|
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);
|
|
|
|
var cacheKey = HashService.ToMd5Hash($"getactivity-{activityIdHash}").Value;
|
|
|
|
var cached = await cache.GetStringAsync(cacheKey, cancellationToken);
|
|
|
|
if (string.IsNullOrWhiteSpace(cached))
|
|
{
|
|
var result = await service.GetActivityAsync(activityIdHash, cancellationToken);
|
|
|
|
if (result.IsFailed) return result;
|
|
|
|
await cache.SetStringAsync(cacheKey, result.Value.ToJson(), cacheOptions, cancellationToken);
|
|
|
|
return result.Value;
|
|
}
|
|
|
|
return Result.Ok(cached.FromJson<Domain.Models.Activity>());
|
|
}));
|
|
|
|
public async Task<Result<Beneficiary[]>> GetBeneficiariesAsync(string projectIdHash, CancellationToken cancellationToken = default) =>
|
|
await Result.Try((Func<Task<Result<Beneficiary[]>>>)(async () =>
|
|
{
|
|
if (!await featureManager.IsEnabledAsync(ServiceCachingFeature))
|
|
return await service.GetBeneficiariesAsync(projectIdHash, cancellationToken);
|
|
|
|
var cacheKey = HashService.ToMd5Hash($"getbeneficiaries-{projectIdHash}").Value;
|
|
|
|
var cached = await cache.GetStringAsync(cacheKey, cancellationToken);
|
|
|
|
if (string.IsNullOrWhiteSpace(cached))
|
|
{
|
|
var result = await service.GetBeneficiariesAsync(projectIdHash, cancellationToken);
|
|
|
|
if (result.IsFailed) return result;
|
|
|
|
await cache.SetStringAsync(cacheKey, result.Value.ToJson(), cacheOptions, cancellationToken);
|
|
|
|
return result.Value;
|
|
}
|
|
|
|
return Result.Ok(cached.FromJson<Beneficiary[]>());
|
|
}));
|
|
|
|
public async Task<Result<Beneficiary>> GetBeneficiaryAsync(string beneficiaryIdHash, CancellationToken cancellationToken = default) =>
|
|
await Result.Try((Func<Task<Result<Beneficiary>>>)(async () =>
|
|
{
|
|
if (!await featureManager.IsEnabledAsync(ServiceCachingFeature))
|
|
return await service.GetBeneficiaryAsync(beneficiaryIdHash, cancellationToken);
|
|
|
|
var cacheKey = HashService.ToMd5Hash($"getbeneficiary-{beneficiaryIdHash}").Value;
|
|
|
|
var cached = await cache.GetStringAsync(cacheKey, cancellationToken);
|
|
|
|
if (string.IsNullOrWhiteSpace(cached))
|
|
{
|
|
var result = await service.GetBeneficiaryAsync(beneficiaryIdHash, cancellationToken);
|
|
|
|
if (result.IsFailed) return result;
|
|
|
|
await cache.SetStringAsync(cacheKey, result.Value.ToJson(), cacheOptions, cancellationToken);
|
|
|
|
return result.Value;
|
|
}
|
|
|
|
return Result.Ok(cached.FromJson<Beneficiary>());
|
|
}));
|
|
|
|
public async Task<Result<ChangeRequest>> GetChangeRequestAsync(string changeRequestIdHash, CancellationToken cancellationToken = default) =>
|
|
await Result.Try((Func<Task<Result<ChangeRequest>>>)(async () =>
|
|
{
|
|
if (!await featureManager.IsEnabledAsync(ServiceCachingFeature))
|
|
return await service.GetChangeRequestAsync(changeRequestIdHash, cancellationToken);
|
|
|
|
var cacheKey = HashService.ToMd5Hash($"getchangerequest-{changeRequestIdHash}").Value;
|
|
|
|
var cached = await cache.GetStringAsync(cacheKey, cancellationToken);
|
|
|
|
if (string.IsNullOrWhiteSpace(cached))
|
|
{
|
|
var result = await service.GetChangeRequestAsync(changeRequestIdHash, cancellationToken);
|
|
|
|
if (result.IsFailed) return result;
|
|
|
|
await cache.SetStringAsync(cacheKey, result.Value.ToJson(), cacheOptions, cancellationToken);
|
|
|
|
return result.Value;
|
|
}
|
|
|
|
return Result.Ok(cached.FromJson<ChangeRequest>());
|
|
}));
|
|
|
|
public async Task<Result<ChangeRequest[]>> GetChangeRequestsAsync(string projectIdHash, CancellationToken cancellationToken = default) =>
|
|
await Result.Try((Func<Task<Result<ChangeRequest[]>>>)(async () =>
|
|
{
|
|
if (!await featureManager.IsEnabledAsync(ServiceCachingFeature))
|
|
return await service.GetChangeRequestsAsync(projectIdHash, cancellationToken);
|
|
|
|
var cacheKey = HashService.ToMd5Hash($"getchangerequests-{projectIdHash}").Value;
|
|
|
|
var cached = await cache.GetStringAsync(cacheKey, cancellationToken);
|
|
|
|
if (string.IsNullOrWhiteSpace(cached))
|
|
{
|
|
var result = await service.GetChangeRequestsAsync(projectIdHash, cancellationToken);
|
|
|
|
if (result.IsFailed) return result;
|
|
|
|
await cache.SetStringAsync(cacheKey, result.Value.ToJson(), cacheOptions, cancellationToken);
|
|
|
|
return result.Value;
|
|
}
|
|
|
|
return Result.Ok(cached.FromJson<ChangeRequest[]>());
|
|
}));
|
|
|
|
public async Task<Result<ComplianceItem>> GetComplianceItemAsync(string complianceItemIdHash, CancellationToken cancellationToken = default) =>
|
|
await Result.Try((Func<Task<Result<ComplianceItem>>>)(async () =>
|
|
{
|
|
if (!await featureManager.IsEnabledAsync(ServiceCachingFeature))
|
|
return await service.GetComplianceItemAsync(complianceItemIdHash, cancellationToken);
|
|
|
|
var cacheKey = HashService.ToMd5Hash($"getcomplianceitem-{complianceItemIdHash}").Value;
|
|
|
|
var cached = await cache.GetStringAsync(cacheKey, cancellationToken);
|
|
|
|
if (string.IsNullOrWhiteSpace(cached))
|
|
{
|
|
var result = await service.GetComplianceItemAsync(complianceItemIdHash, cancellationToken);
|
|
|
|
if (result.IsFailed) return result;
|
|
|
|
await cache.SetStringAsync(cacheKey, result.Value.ToJson(), cacheOptions, cancellationToken);
|
|
|
|
return result.Value;
|
|
}
|
|
|
|
return Result.Ok(cached.FromJson<ComplianceItem>());
|
|
}));
|
|
|
|
public async Task<Result<ComplianceItem[]>> GetComplianceItemsAsync(string projectIdHash, CancellationToken cancellationToken = default) =>
|
|
await Result.Try((Func<Task<Result<ComplianceItem[]>>>)(async () =>
|
|
{
|
|
if (!await featureManager.IsEnabledAsync(ServiceCachingFeature))
|
|
return await service.GetComplianceItemsAsync(projectIdHash, cancellationToken);
|
|
|
|
var cacheKey = HashService.ToMd5Hash($"getcomplianceitems-{projectIdHash}").Value;
|
|
|
|
var cached = await cache.GetStringAsync(cacheKey, cancellationToken);
|
|
|
|
if (string.IsNullOrWhiteSpace(cached))
|
|
{
|
|
var result = await service.GetComplianceItemsAsync(projectIdHash, cancellationToken);
|
|
|
|
if (result.IsFailed) return result;
|
|
|
|
await cache.SetStringAsync(cacheKey, result.Value.ToJson(), cacheOptions, cancellationToken);
|
|
|
|
return result.Value;
|
|
}
|
|
|
|
return Result.Ok(cached.FromJson<ComplianceItem[]>());
|
|
}));
|
|
|
|
public async Task<Result<Issue>> GetIssueAsync(string issueIdHash, CancellationToken cancellationToken = default) =>
|
|
await Result.Try((Func<Task<Result<Issue>>>)(async () =>
|
|
{
|
|
if (!await featureManager.IsEnabledAsync(ServiceCachingFeature))
|
|
return await service.GetIssueAsync(issueIdHash, cancellationToken);
|
|
|
|
var cacheKey = HashService.ToMd5Hash($"getissue-{issueIdHash}").Value;
|
|
|
|
var cached = await cache.GetStringAsync(cacheKey, cancellationToken);
|
|
|
|
if (string.IsNullOrWhiteSpace(cached))
|
|
{
|
|
var result = await service.GetIssueAsync(issueIdHash, cancellationToken);
|
|
|
|
if (result.IsFailed) return result;
|
|
|
|
await cache.SetStringAsync(cacheKey, result.Value.ToJson(), cacheOptions, cancellationToken);
|
|
|
|
return result.Value;
|
|
}
|
|
|
|
return Result.Ok(cached.FromJson<Issue>());
|
|
}));
|
|
|
|
public async Task<Result<Issue[]>> GetIssuesAsync(string projectIdHash, CancellationToken cancellationToken = default) =>
|
|
await Result.Try((Func<Task<Result<Issue[]>>>)(async () =>
|
|
{
|
|
if (!await featureManager.IsEnabledAsync(ServiceCachingFeature))
|
|
return await service.GetIssuesAsync(projectIdHash, cancellationToken);
|
|
|
|
var cacheKey = HashService.ToMd5Hash($"getissues-{projectIdHash}").Value;
|
|
|
|
var cached = await cache.GetStringAsync(cacheKey, cancellationToken);
|
|
|
|
if (string.IsNullOrWhiteSpace(cached))
|
|
{
|
|
var result = await service.GetIssuesAsync(projectIdHash, cancellationToken);
|
|
|
|
if (result.IsFailed) return result;
|
|
|
|
await cache.SetStringAsync(cacheKey, result.Value.ToJson(), cacheOptions, cancellationToken);
|
|
|
|
return result.Value;
|
|
}
|
|
|
|
return Result.Ok(cached.FromJson<Issue[]>());
|
|
}));
|
|
|
|
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);
|
|
|
|
var cacheKey = HashService.ToMd5Hash($"getmilestone-{milestoneIdHash}").Value;
|
|
|
|
var cached = await cache.GetStringAsync(cacheKey, cancellationToken);
|
|
|
|
if (string.IsNullOrWhiteSpace(cached))
|
|
{
|
|
var result = await service.GetMilestoneAsync(milestoneIdHash, cancellationToken);
|
|
|
|
if (result.IsFailed) return result;
|
|
|
|
await cache.SetStringAsync(cacheKey, result.Value.ToJson(), cacheOptions, cancellationToken);
|
|
|
|
return result.Value;
|
|
}
|
|
|
|
return Result.Ok(cached.FromJson<Milestone>());
|
|
}));
|
|
|
|
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);
|
|
|
|
var cacheKey = HashService.ToMd5Hash($"getmilestones-{pagination.Index}-{pagination.PageSize}-{pagination.Page}").Value;
|
|
|
|
var cached = await cache.GetStringAsync(cacheKey, cancellationToken);
|
|
|
|
if (string.IsNullOrWhiteSpace(cached))
|
|
{
|
|
var result = await service.GetMilestonesAsync(pagination, cancellationToken);
|
|
|
|
if (result.IsFailed) return result;
|
|
|
|
await cache.SetStringAsync(cacheKey, result.Value.ToJson(), cacheOptions, cancellationToken);
|
|
|
|
return result.Value;
|
|
}
|
|
|
|
return Result.Ok(cached.FromJson<Milestone[]>());
|
|
}));
|
|
|
|
public async Task<Result<Outcome>> GetOutcomeAsync(string outcomeIdHash, CancellationToken cancellationToken = default) =>
|
|
await Result.Try((Func<Task<Result<Outcome>>>)(async () =>
|
|
{
|
|
if (!await featureManager.IsEnabledAsync(ServiceCachingFeature))
|
|
return await service.GetOutcomeAsync(outcomeIdHash, cancellationToken);
|
|
|
|
var cacheKey = HashService.ToMd5Hash($"getoutcome-{outcomeIdHash}").Value;
|
|
|
|
var cached = await cache.GetStringAsync(cacheKey, cancellationToken);
|
|
|
|
if (string.IsNullOrWhiteSpace(cached))
|
|
{
|
|
var result = await service.GetOutcomeAsync(outcomeIdHash, cancellationToken);
|
|
|
|
if (result.IsFailed) return result;
|
|
|
|
await cache.SetStringAsync(cacheKey, result.Value.ToJson(), cacheOptions, cancellationToken);
|
|
|
|
return result.Value;
|
|
}
|
|
|
|
return Result.Ok(cached.FromJson<Outcome>());
|
|
}));
|
|
|
|
public async Task<Result<Outcome[]>> GetOutcomesAsync(string beneficiaryIdHash, CancellationToken cancellationToken = default) =>
|
|
await Result.Try((Func<Task<Result<Outcome[]>>>)(async () =>
|
|
{
|
|
if (!await featureManager.IsEnabledAsync(ServiceCachingFeature))
|
|
return await service.GetOutcomesAsync(beneficiaryIdHash, cancellationToken);
|
|
|
|
var cacheKey = HashService.ToMd5Hash($"getoutcomes-{beneficiaryIdHash}").Value;
|
|
|
|
var cached = await cache.GetStringAsync(cacheKey, cancellationToken);
|
|
|
|
if (string.IsNullOrWhiteSpace(cached))
|
|
{
|
|
var result = await service.GetOutcomesAsync(beneficiaryIdHash, cancellationToken);
|
|
|
|
if (result.IsFailed) return result;
|
|
|
|
await cache.SetStringAsync(cacheKey, result.Value.ToJson(), cacheOptions, cancellationToken);
|
|
|
|
return result.Value;
|
|
}
|
|
|
|
return Result.Ok(cached.FromJson<Outcome[]>());
|
|
}));
|
|
|
|
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);
|
|
|
|
var cacheKey = HashService.ToMd5Hash($"getprogramme-{programmeIdHash}").Value;
|
|
|
|
var cached = await cache.GetStringAsync(cacheKey, cancellationToken);
|
|
|
|
if (string.IsNullOrWhiteSpace(cached))
|
|
{
|
|
var result = await service.GetProgrammeAsync(programmeIdHash, cancellationToken);
|
|
|
|
if (result.IsFailed) return result;
|
|
|
|
await cache.SetStringAsync(cacheKey, result.Value.ToJson(), cacheOptions, cancellationToken);
|
|
|
|
return result.Value;
|
|
}
|
|
|
|
return Result.Ok(cached!.FromJson<Programme>());
|
|
}));
|
|
|
|
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);
|
|
|
|
var cacheKey = HashService.ToMd5Hash($"getprogrammeprojects-{programmeIdHash}").Value;
|
|
|
|
var cached = await cache.GetStringAsync(cacheKey, cancellationToken);
|
|
|
|
if (string.IsNullOrWhiteSpace(cached))
|
|
{
|
|
var result = await service.GetProgrammeProjectsAsync(programmeIdHash, cancellationToken);
|
|
|
|
if (result.IsFailed) return result;
|
|
|
|
await cache.SetStringAsync(cacheKey, result.Value.ToJson(), cacheOptions, cancellationToken);
|
|
|
|
return result.Value;
|
|
}
|
|
|
|
return Result.Ok(cached.FromJson<Project[]>());
|
|
}));
|
|
|
|
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);
|
|
|
|
var cacheKey = HashService.ToMd5Hash($"getprogrammes-{pagination.Index}-{pagination.PageSize}-{pagination.Page}").Value;
|
|
|
|
var cached = await cache.GetStringAsync(cacheKey, cancellationToken);
|
|
|
|
if (string.IsNullOrWhiteSpace(cached))
|
|
{
|
|
var result = await service.GetProgrammesAsync(pagination, cancellationToken);
|
|
|
|
if (result.IsFailed) return result;
|
|
|
|
await cache.SetStringAsync(cacheKey, result.Value.ToJson(), cacheOptions, cancellationToken);
|
|
|
|
return result.Value;
|
|
}
|
|
|
|
return Result.Ok(cached.FromJson<Programme[]>());
|
|
}));
|
|
|
|
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);
|
|
|
|
var cacheKey = HashService.ToMd5Hash($"getproject-{projectIdHash}").Value;
|
|
|
|
var cached = await cache.GetStringAsync(cacheKey, cancellationToken);
|
|
|
|
if (string.IsNullOrWhiteSpace(cached))
|
|
{
|
|
var result = await service.GetProjectAsync(projectIdHash, cancellationToken);
|
|
|
|
if (result.IsFailed) return result;
|
|
|
|
await cache.SetStringAsync(cacheKey, result.Value.ToJson(), cacheOptions, cancellationToken);
|
|
|
|
return result.Value;
|
|
}
|
|
|
|
return Result.Ok(cached.FromJson<Project>());
|
|
}));
|
|
|
|
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);
|
|
|
|
var cacheKey = HashService.ToMd5Hash($"getprojectindicators-{projectIdHash}").Value;
|
|
|
|
var cached = await cache.GetStringAsync(cacheKey, cancellationToken);
|
|
|
|
if (string.IsNullOrWhiteSpace(cached))
|
|
{
|
|
var result = await service.GetProjectIndicatorsAsync(projectIdHash, cancellationToken);
|
|
|
|
if (result.IsFailed) return result;
|
|
|
|
await cache.SetStringAsync(cacheKey, result.Value.ToJson(), cacheOptions, cancellationToken);
|
|
|
|
return result.Value;
|
|
}
|
|
|
|
return Result.Ok(cached.FromJson<Indicator[]>());
|
|
}));
|
|
|
|
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);
|
|
|
|
var cacheKey = HashService.ToMd5Hash($"getprojectmilestones-{projectIdHash}").Value;
|
|
|
|
var cached = await cache.GetStringAsync(cacheKey, cancellationToken);
|
|
|
|
if (string.IsNullOrWhiteSpace(cached))
|
|
{
|
|
var result = await service.GetProjectMilestonesAsync(projectIdHash, cancellationToken);
|
|
|
|
if (result.IsFailed) return result;
|
|
|
|
await cache.SetStringAsync(cacheKey, result.Value.ToJson(), cacheOptions, cancellationToken);
|
|
|
|
return result.Value;
|
|
}
|
|
|
|
return Result.Ok(cached.FromJson<Milestone[]>());
|
|
}));
|
|
|
|
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);
|
|
|
|
var cacheKey = HashService.ToMd5Hash($"getprojectrisks-{projectIdHash}").Value;
|
|
|
|
var cached = await cache.GetStringAsync(cacheKey, cancellationToken);
|
|
|
|
if (string.IsNullOrWhiteSpace(cached))
|
|
{
|
|
var result = await service.GetProjectRisksAsync(projectIdHash, cancellationToken);
|
|
|
|
if (result.IsFailed) return result;
|
|
|
|
await cache.SetStringAsync(cacheKey, result.Value.ToJson(), cacheOptions, cancellationToken);
|
|
|
|
return result.Value;
|
|
}
|
|
|
|
return Result.Ok(cached.FromJson<Risk[]>());
|
|
}));
|
|
|
|
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);
|
|
|
|
var cacheKey = HashService.ToMd5Hash($"getprojects-{pagination.Index}-{pagination.Page}-{pagination.PageSize}").Value;
|
|
|
|
var cached = await cache.GetStringAsync(cacheKey, cancellationToken);
|
|
|
|
if (string.IsNullOrWhiteSpace(cached))
|
|
{
|
|
var result = await service.GetProjectsAsync(pagination, cancellationToken);
|
|
|
|
if (result.IsFailed) return result;
|
|
|
|
await cache.SetStringAsync(cacheKey, result.Value.ToJson(), cacheOptions, cancellationToken);
|
|
|
|
return result.Value;
|
|
}
|
|
|
|
return Result.Ok(cached.FromJson<Project[]>());
|
|
}));
|
|
|
|
public async Task<Result<SiteVisit>> GetSiteVisitAsync(string siteVisitIdHash, CancellationToken cancellationToken = default) =>
|
|
await Result.Try((Func<Task<Result<SiteVisit>>>)(async () =>
|
|
{
|
|
if (!await featureManager.IsEnabledAsync(ServiceCachingFeature))
|
|
return await service.GetSiteVisitAsync(siteVisitIdHash, cancellationToken);
|
|
|
|
var cacheKey = HashService.ToMd5Hash($"getsitevisit-{siteVisitIdHash}").Value;
|
|
|
|
var cached = await cache.GetStringAsync(cacheKey, cancellationToken);
|
|
|
|
if (string.IsNullOrWhiteSpace(cached))
|
|
{
|
|
var result = await service.GetSiteVisitAsync(siteVisitIdHash, cancellationToken);
|
|
|
|
if (result.IsFailed) return result;
|
|
|
|
await cache.SetStringAsync(cacheKey, result.Value.ToJson(), cacheOptions, cancellationToken);
|
|
|
|
return result.Value;
|
|
}
|
|
|
|
return Result.Ok(cached.FromJson<SiteVisit>());
|
|
}));
|
|
|
|
public async Task<Result<SiteVisit[]>> GetSiteVisitsAsync(string projectIdHash, CancellationToken cancellationToken = default) =>
|
|
await Result.Try((Func<Task<Result<SiteVisit[]>>>)(async () =>
|
|
{
|
|
if (!await featureManager.IsEnabledAsync(ServiceCachingFeature))
|
|
return await service.GetSiteVisitsAsync(projectIdHash, cancellationToken);
|
|
|
|
var cacheKey = HashService.ToMd5Hash($"getsitevisits-{projectIdHash}").Value;
|
|
|
|
var cached = await cache.GetStringAsync(cacheKey, cancellationToken);
|
|
|
|
if (string.IsNullOrWhiteSpace(cached))
|
|
{
|
|
var result = await service.GetSiteVisitsAsync(projectIdHash, cancellationToken);
|
|
|
|
if (result.IsFailed) return result;
|
|
|
|
await cache.SetStringAsync(cacheKey, result.Value.ToJson(), cacheOptions, cancellationToken);
|
|
|
|
return result.Value;
|
|
}
|
|
|
|
return Result.Ok(cached.FromJson<SiteVisit[]>());
|
|
}));
|
|
|
|
public async Task<Result> UpdateBeneficiaryAsync(UpdateBeneficiaryRequest request, Guid userId, CancellationToken cancellationToken = default) =>
|
|
await service.UpdateBeneficiaryAsync(request, userId, cancellationToken);
|
|
|
|
public async Task<Result> UpdateChangeRequestAsync(UpdateChangeRequest request, Guid userId, CancellationToken cancellationToken = default) =>
|
|
await service.UpdateChangeRequestAsync(request, userId, cancellationToken);
|
|
|
|
public async Task<Result> UpdateComplianceItemAsync(UpdateComplianceItemRequest request, Guid userId, CancellationToken cancellationToken = default) =>
|
|
await service.UpdateComplianceItemAsync(request, userId, cancellationToken);
|
|
|
|
public async Task<Result> UpdateIssueAsync(UpdateIssueRequest request, Guid userId, CancellationToken cancellationToken = default) =>
|
|
await service.UpdateIssueAsync(request, userId, cancellationToken);
|
|
|
|
public async Task<Result> UpdateMilestoneAsync(UpdateMilestoneRequest request, Guid userId, CancellationToken cancellationToken = default) =>
|
|
await service.UpdateMilestoneAsync(request, userId, cancellationToken);
|
|
|
|
public async Task<Result> UpdateOutcomeAsync(UpdateOutcomeRequest request, Guid userId, CancellationToken cancellationToken = default) =>
|
|
await service.UpdateOutcomeAsync(request, userId, cancellationToken);
|
|
|
|
public async Task<Result> UpdateProgrammeAsync(UpdateProgrammeRequest request, Guid userId, CancellationToken cancellationToken = default) =>
|
|
await service.UpdateProgrammeAsync(request, userId, cancellationToken);
|
|
|
|
public async Task<Result> UpdateProjectAsync(UpdateProjectRequest request, Guid userId, CancellationToken cancellationToken = default) =>
|
|
await service.UpdateProjectAsync(request, userId, cancellationToken);
|
|
|
|
public async Task<Result> UpdateProjectStatusAsync(UpdateProjectStatusRequest request, Guid userId, CancellationToken cancellationToken = default) =>
|
|
await service.UpdateProjectStatusAsync(request, userId, cancellationToken);
|
|
|
|
public async Task<Result> UpdateSiteVisitAsync(UpdateSiteVisitRequest request, Guid userId, CancellationToken cancellationToken = default) =>
|
|
await service.UpdateSiteVisitAsync(request, userId, cancellationToken);
|
|
}
|