pfm/PostFundManagement.Application/Services/Grants/GrantsCacheService.cs

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;

namespace PostFundManagement.Application.Services.Grants;

public sealed class GrantsCacheService(GrantsService service, IDistributedCache cache) : ServiceCacheBase, IGrantsService
{
    public async ValueTask<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) =>
        await service.CreateBudgetAsync(request, userId, cancellationToken);

    public async ValueTask<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) =>
        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 () =>
        {
            var cacheKey = HashService.ToMd5Hash($"getaward-{awardIdHash}").Value;

            var cached = await cache.GetStringAsync(cacheKey, cancellationToken);

            if (string.IsNullOrWhiteSpace(cached))
            {
                var result = await service.GetAwardAsync(awardIdHash, cancellationToken);

                if (result.IsFailed) return result;

                await cache.SetStringAsync(cacheKey, result.Value.ToJson(), cacheOptions, cancellationToken);

                return result.Value;
            }

            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 () =>
        {
            var cacheKey = HashService.ToMd5Hash($"getawards-{pagination.Page}-{pagination.PageSize}-{pagination.Index}").Value;

            var cached = await cache.GetStringAsync(cacheKey, cancellationToken);

            if (string.IsNullOrWhiteSpace(cached))
            {
                var result = await service.GetAwardsAsync(pagination, cancellationToken);

                if (result.IsFailed) return result;

                await cache.SetStringAsync(cacheKey, result.Value.ToJson(), cacheOptions, cancellationToken);

                return result.Value;
            }

            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 () =>
        {
            var cacheKey = HashService.ToMd5Hash($"getbudget-{budgetIdHash}").Value;

            var cached = await cache.GetStringAsync(cacheKey, cancellationToken);

            if (string.IsNullOrWhiteSpace(cached))
            {
                var result = await service.GetBudgetAsync(budgetIdHash, cancellationToken);

                if (result.IsFailed) return result;

                await cache.SetStringAsync(cacheKey, result.Value.ToJson(), cacheOptions, cancellationToken);

                return result.Value;
            }

            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 () =>
        {
            var cacheKey = HashService.ToMd5Hash($"getbudgets-{pagination.Page}-{pagination.PageSize}-{pagination.Index}").Value;

            var cached = await cache.GetStringAsync(cacheKey, cancellationToken);

            if (string.IsNullOrWhiteSpace(cached))
            {
                var result = await service.GetBudgetsAsync(pagination, cancellationToken);

                if (result.IsFailed) return result;

                await cache.SetStringAsync(cacheKey, result.Value.ToJson(), cacheOptions, cancellationToken);

                return result.Value;
            }

            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 () =>
        {
            var cacheKey = HashService.ToMd5Hash($"getctract-{contractIdHash}").Value;

            var cached = await cache.GetStringAsync(cacheKey, cancellationToken);

            if (string.IsNullOrWhiteSpace(cached))
            {
                var result = await service.GetContractAsync(contractIdHash, cancellationToken);

                if (result.IsFailed) return result;

                await cache.SetStringAsync(cacheKey, result.Value.ToJson(), cacheOptions, cancellationToken);

                return result.Value;
            }

            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 () =>
        {
            var cacheKey = HashService.ToMd5Hash($"getcontracts-{pagination.Index}-{pagination.PageSize}-{pagination.Page}").Value;

            var cached = await cache.GetStringAsync(cacheKey, cancellationToken);

            if (string.IsNullOrWhiteSpace(cached))
            {
                var result = await service.GetContractsAsync(pagination, cancellationToken);

                if (result.IsFailed) return result;

                await cache.SetStringAsync(cacheKey, result.Value.ToJson(), cacheOptions, cancellationToken);

                return result.Value;
            }

            return Result.Ok(cached.FromJson<Contract[]>());
        }));
}