Lab4/Server/Services/IdempotencyService.cs - master - ivanstrike/tasker

Lab4/Server/Services/IdempotencyService.cs
105 строк3 KB
ivanstrike
laba4
21 дек 2025, 21:13
21 дек 2025, 21:13e9bb9a2
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.Logging;
using TaskerMQ.Server.Configuration;
using TaskerMQ.Server.Data;
using TaskerMQ.Server.Models;

namespace TaskerMQ.Server.Services;

public class IdempotencyService
{
    private readonly ApplicationDbContext _context;
    private readonly IdempotencySettings _settings;
    private readonly ILogger<IdempotencyService> _logger;

    public IdempotencyService(
        ApplicationDbContext context,
        IdempotencySettings settings,
        ILogger<IdempotencyService> logger)
    {
        _context = context;
        _settings = settings;
        _logger = logger;
    }

    public async Task<string?> GetCachedResponseAsync(string requestId)
    {
        try
        {
            var cachedRequest = await _context.IdempotentRequests
                .FirstOrDefaultAsync(r => r.RequestId == requestId);

            if (cachedRequest != null)
            {
                var expirationTime = cachedRequest.ProcessedAt
                    .AddMinutes(_settings.CacheDurationMinutes);

                if (DateTime.UtcNow < expirationTime)
                {
                    _logger.LogInformation(
                        "Found cached response for request {RequestId}", requestId);
                    return cachedRequest.Response;
                }

                // Remove expired cache entry
                _context.IdempotentRequests.Remove(cachedRequest);
                await _context.SaveChangesAsync();
            }

            return null;
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "Error checking cached response for {RequestId}", requestId);
            return null;
        }
    }

    public async Task CacheResponseAsync(string requestId, string response)
    {
        try
        {
            var idempotentRequest = new IdempotentRequest
            {
                RequestId = requestId,
                Response = response,
                ProcessedAt = DateTime.UtcNow
            };

            _context.IdempotentRequests.Add(idempotentRequest);
            await _context.SaveChangesAsync();

            _logger.LogInformation("Cached response for request {RequestId}", requestId);
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "Error caching response for {RequestId}", requestId);
        }
    }

    public async Task CleanupExpiredCacheAsync()
    {
        try
        {
            var expirationTime = DateTime.UtcNow
                .AddMinutes(-_settings.CacheDurationMinutes);

            var expiredRequests = await _context.IdempotentRequests
                .Where(r => r.ProcessedAt < expirationTime)
                .ToListAsync();

            if (expiredRequests.Any())
            {
                _context.IdempotentRequests.RemoveRange(expiredRequests);
                await _context.SaveChangesAsync();

                _logger.LogInformation(
                    "Cleaned up {Count} expired cache entries", expiredRequests.Count);
            }
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "Error cleaning up expired cache");
        }
    }
}