refactor: simplies code

Author: joaopaulopmedeiros

src/Iris.WebApi/Modules/Indicators/Features/GetByRange/GetIndicatorsByRangeEndpoint.cs

@@ -1,13 +1,10 @@
 using FluentValidation;
 using FluentValidation.Results;
 
-using Iris.WebApi.Modules.Indicators.Features.Ingestion.Models;
-using Iris.WebApi.Modules.Indicators.Mappers;
 using Iris.WebApi.Modules.Indicators.Models;
+using Iris.WebApi.Modules.Indicators.Repositories;
 using Iris.WebApi.Shared.Validation;
 
-using StackExchange.Redis;
-
 namespace Iris.WebApi.Modules.Indicators.Features.GetByRange;
 
 public static class GetIndicatorsByRangeEndpoint
@@ -25,7 +22,7 @@ private static async Task<IResult> HandleAsync(
         HttpContext context,
         [AsParameters] GetIndicatorsByRangeRequest request,
         IValidator<GetIndicatorsByRangeRequest> validator,
-        IDatabase redis)
+        IIndicatorTimeSeriesRepository repository)
     {
         ValidationResult validationResult = await validator.ValidateAsync(request);
 
@@ -34,19 +31,11 @@ private static async Task<IResult> HandleAsync(
             return Results.BadRequest(validationResult.ToApiResponse());
         }
 
-        RedisResult timeSeries = await redis.ExecuteAsync(
-            "TS.RANGE",
-            IndicatorConfigs.GetByCode(request.Code).RedisKey,
-            request.From.ToUnixMilliseconds(),
-            request.To.ToUnixMilliseconds());
-
-        if (timeSeries.IsNull || timeSeries.Length == 0)
-        {
-            return Results.NoContent();
-        }
-
-        IEnumerable<Indicator> data = IndicatorMapper.Map((RedisResult[])timeSeries!);
+        IEnumerable<Indicator> indicators = await repository
+            .GetIndicatorsAsync(request.Code, request.From, request.To);
 
-        return Results.Ok(new GetIndicatorsByRangeResponse(request.Code, data));
+        return indicators is null || !indicators.Any()
+            ? Results.NoContent()
+            : Results.Ok(new GetIndicatorsByRangeResponse(request.Code, indicators));
     }
 }

src/Iris.WebApi/Modules/Indicators/Features/GetByRange/GetIndicatorsByRangeRequestValidator.cs

@@ -1,6 +1,6 @@
 using FluentValidation;
 
-using Iris.WebApi.Modules.Indicators.Features.Ingestion.Models;
+using Iris.WebApi.Modules.Indicators.Features.Ingestion;
 
 namespace Iris.WebApi.Modules.Indicators.Features.GetByRange;
 

src/Iris.WebApi/Modules/Indicators/Features/Ingestion/BaseIndicatorIngestionJob.cs

@@ -1,55 +1,41 @@
-using System.Globalization;
-
-using Iris.WebApi.Modules.Indicators.Features.Ingestion.Models;
+using Iris.WebApi.Modules.Indicators.Mappers;
+using Iris.WebApi.Modules.Indicators.Repositories;
 using Iris.WebApi.Shared.Infra.Http.Clients.BCB;
 using Iris.WebApi.Shared.Infra.Http.Clients.BCB.Loggers;
 using Iris.WebApi.Shared.Infra.Http.Clients.BCB.Models;
 
 using Refit;
 
-using StackExchange.Redis;
-
 namespace Iris.WebApi.Modules.Indicators.Features.Ingestion;
 
 [AutomaticRetry(Attempts = 1)]
 public abstract class BaseIndicatorIngestionJob<TJob>(
     ILogger<TJob> logger,
     IBCBHttpClient httpClient,
-    IConnectionMultiplexer redis) where TJob : BaseIndicatorIngestionJob<TJob>
+    IIndicatorTimeSeriesRepository repository) where TJob : BaseIndicatorIngestionJob<TJob>
 {
     protected abstract IndicatorConfig Config { get; }
     protected readonly IBCBHttpClient _httpClient = httpClient;
 
     public async Task ExecuteAsync()
     {
-        IDatabase db = redis.GetDatabase();
-
-        if (!await db.KeyExistsAsync(Config.RedisKey))
-        {
-            await db.ExecuteAsync(
-                "TS.CREATE",
-                Config.RedisKey,
-                "RETENTION", 0,
-                "CHUNK_SIZE", 128,
-                "DUPLICATE_POLICY", "LAST",
-                "LABELS", "code", Config.Code.ToLower());
-        }
+        await repository.EnsureTimeSeriesExistsAsync(Config);
 
         DateOnly today = DateOnly.FromDateTime(DateTime.Now);
-        DateOnly from = await GetStartDateAsync(db, today);
+        DateOnly from = await repository.GetNextIngestionDateAsync(Config, today);
         DateOnly to = today;
 
         try
         {
-            IEnumerable<Indicator> indicators = await GetIndicatorDataAsync(new IndicatorQueryParams(from, to));
+            IEnumerable<RawIndicator> indicators = await GetIndicatorDataAsync(new IndicatorQueryParams(from, to));
 
             if (indicators is null || !indicators.Any())
             {
                 logger.LogNoDataFound(from, to);
                 return;
             }
 
-            await AddIndicatorsAsync(db, indicators);
+            await repository.AppendAsync(Config, IndicatorMapper.Map(indicators));
         }
         catch (ApiException ex) when (ex.StatusCode == System.Net.HttpStatusCode.NotFound)
         {
@@ -62,58 +48,5 @@ await db.ExecuteAsync(
         }
     }
 
-    protected abstract Task<IEnumerable<Indicator>> GetIndicatorDataAsync(IndicatorQueryParams queryParams);
-
-    private async Task<DateOnly> GetStartDateAsync(IDatabase db, DateOnly today)
-    {
-        try
-        {
-            RedisResult result = await db.ExecuteAsync("TS.GET", Config.RedisKey);
-
-            if (result.IsNull)
-            {
-                return today.AddYears(-10);
-            }
-
-            RedisResult[] parts = (RedisResult[])result!;
-
-            if (parts == null || parts.Length == 0)
-            {
-                return today.AddYears(-10);
-            }
-
-            long lastTimestamp = (long)parts[0];
-
-            DateOnly lastDate = DateOnly.FromDateTime(
-                DateTimeOffset.FromUnixTimeMilliseconds(lastTimestamp).DateTime
-            );
-
-            return lastDate.AddDays(1);
-        }
-        catch (Exception)
-        {
-            return today.AddYears(-10);
-        }
-    }
-
-    private async Task AddIndicatorsAsync(IDatabase db, IEnumerable<Indicator> indicators)
-    {
-        var indicatorsArray = indicators.ToArray();
-        if (indicatorsArray.Length == 0) return;
-
-        var args = new object[indicatorsArray.Length * 3];
-        int index = 0;
-
-        foreach (var indicator in indicatorsArray)
-        {
-            long timestamp = new DateTimeOffset(indicator.Date.ToDateTime(TimeOnly.MinValue))
-                .ToUnixTimeMilliseconds();
-
-            args[index++] = Config.RedisKey;
-            args[index++] = timestamp;
-            args[index++] = indicator.Value.ToString(CultureInfo.InvariantCulture);
-        }
-
-        await db.ExecuteAsync("TS.MADD", args);
-    }
+    protected abstract Task<IEnumerable<RawIndicator>> GetIndicatorDataAsync(IndicatorQueryParams queryParams);
 }

src/Iris.WebApi/Modules/Indicators/Features/Ingestion/IndicatorConfig.cs

@@ -1,6 +1,4 @@
-using Iris.WebApi.Modules.Indicators.Features.GetByRange;
-
-namespace Iris.WebApi.Modules.Indicators.Features.Ingestion.Models;
+namespace Iris.WebApi.Modules.Indicators.Features.Ingestion;
 
 public record struct IndicatorConfig(
     string Code,

src/Iris.WebApi/Modules/Indicators/Features/Ingestion/IpcaIngestionJob.cs

@@ -1,19 +1,17 @@
-using Iris.WebApi.Modules.Indicators.Features.Ingestion.Models;
+using Iris.WebApi.Modules.Indicators.Repositories;
 using Iris.WebApi.Shared.Infra.Http.Clients.BCB;
 using Iris.WebApi.Shared.Infra.Http.Clients.BCB.Models;
 
-using StackExchange.Redis;
-
 namespace Iris.WebApi.Modules.Indicators.Features.Ingestion;
 
 public class IpcaIngestionJob(
     ILogger<IpcaIngestionJob> logger,
     IBCBHttpClient httpClient,
-    IConnectionMultiplexer redis) : BaseIndicatorIngestionJob<IpcaIngestionJob>(logger, httpClient, redis)
+    IIndicatorTimeSeriesRepository repository) : BaseIndicatorIngestionJob<IpcaIngestionJob>(logger, httpClient, repository)
 {
     protected override IndicatorConfig Config => IndicatorConfigs.Ipca;
 
-    protected override async Task<IEnumerable<Indicator>> GetIndicatorDataAsync(IndicatorQueryParams queryParams)
+    protected override async Task<IEnumerable<RawIndicator>> GetIndicatorDataAsync(IndicatorQueryParams queryParams)
     {
         return await _httpClient.GetIpcaAsync(queryParams);
     }

src/Iris.WebApi/Modules/Indicators/Features/Ingestion/SelicIngestionJob.cs

@@ -1,19 +1,17 @@
-using Iris.WebApi.Modules.Indicators.Features.Ingestion.Models;
+using Iris.WebApi.Modules.Indicators.Repositories;
 using Iris.WebApi.Shared.Infra.Http.Clients.BCB;
 using Iris.WebApi.Shared.Infra.Http.Clients.BCB.Models;
 
-using StackExchange.Redis;
-
 namespace Iris.WebApi.Modules.Indicators.Features.Ingestion;
 
 public class SelicIngestionJob(
     ILogger<SelicIngestionJob> logger,
     IBCBHttpClient httpClient,
-    IConnectionMultiplexer redis) : BaseIndicatorIngestionJob<SelicIngestionJob>(logger, httpClient, redis)
+    IIndicatorTimeSeriesRepository repository) : BaseIndicatorIngestionJob<SelicIngestionJob>(logger, httpClient, repository)
 {
     protected override IndicatorConfig Config => IndicatorConfigs.Selic;
 
-    protected override async Task<IEnumerable<Indicator>> GetIndicatorDataAsync(IndicatorQueryParams queryParams)
+    protected override async Task<IEnumerable<RawIndicator>> GetIndicatorDataAsync(IndicatorQueryParams queryParams)
     {
         return await _httpClient.GetSelicAsync(queryParams);
     }

src/Iris.WebApi/Modules/Indicators/IoC/DependencyInjector.cs

@@ -2,12 +2,18 @@
 
 using Iris.WebApi.Modules.Indicators.Features.GetByRange;
 using Iris.WebApi.Modules.Indicators.Features.Ingestion;
-using Iris.WebApi.Modules.Indicators.Features.Ingestion.Models;
+using Iris.WebApi.Modules.Indicators.Repositories;
 
 namespace Iris.WebApi.Modules.Indicators.IoC;
 
 public static class DependencyInjector
 {
+    public static IServiceCollection AddIndicatorsRepositories(this IServiceCollection services)
+    {
+        services.AddScoped<IIndicatorTimeSeriesRepository, RedisTimeSeriesRepository>();
+        return services;
+    }
+
     public static IServiceCollection AddIndicatorsValidators(this IServiceCollection services)
     {
         services.AddScoped<IValidator<GetIndicatorsByRangeRequest>, GetIndicatorsByRangeRequestValidator>();

src/Iris.WebApi/Modules/Indicators/Mappers/IndicatorMapper.cs

@@ -1,6 +1,7 @@
 using System.Globalization;
 
 using Iris.WebApi.Modules.Indicators.Models;
+using Iris.WebApi.Shared.Infra.Http.Clients.BCB.Models;
 
 using StackExchange.Redis;
 
@@ -23,4 +24,9 @@ public static IEnumerable<Indicator> Map(RedisResult[] results)
             return new Indicator(parsedDate, parsedValue);
         });
     }
+
+    public static Indicator Map(RawIndicator raw) => new(raw.Date, raw.Value);
+
+    public static IEnumerable<Indicator> Map(IEnumerable<RawIndicator> raw) =>
+        raw.Select(Map);
 }

src/Iris.WebApi/Modules/Indicators/Repositories/IIndicatorTimeSeriesRepository.cs

@@ -0,0 +1,15 @@
+using Iris.WebApi.Modules.Indicators.Features.Ingestion;
+using Iris.WebApi.Modules.Indicators.Models;
+
+namespace Iris.WebApi.Modules.Indicators.Repositories;
+
+public interface IIndicatorTimeSeriesRepository
+{
+    Task EnsureTimeSeriesExistsAsync(IndicatorConfig config);
+
+    Task<DateOnly> GetNextIngestionDateAsync(IndicatorConfig config, DateOnly today);
+
+    Task AppendAsync(IndicatorConfig config, IEnumerable<Indicator> indicators);
+
+    Task<IEnumerable<Indicator>> GetIndicatorsAsync(string code, DateOnly from, DateOnly to);
+}

src/Iris.WebApi/Modules/Indicators/Repositories/RedisTimeSeriesRepository.cs

@@ -0,0 +1,101 @@
+using System.Globalization;
+
+using Iris.WebApi.Modules.Indicators.Features.Ingestion;
+using Iris.WebApi.Modules.Indicators.Mappers;
+using Iris.WebApi.Modules.Indicators.Models;
+
+using StackExchange.Redis;
+
+namespace Iris.WebApi.Modules.Indicators.Repositories;
+
+public sealed class RedisTimeSeriesRepository(IDatabase redis) : IIndicatorTimeSeriesRepository
+{
+    public async Task EnsureTimeSeriesExistsAsync(IndicatorConfig config)
+    {
+        if (await redis.KeyExistsAsync(config.RedisKey))
+            return;
+
+        await redis.ExecuteAsync(
+            "TS.CREATE",
+            config.RedisKey,
+            "RETENTION", 0,
+            "CHUNK_SIZE", 128,
+            "DUPLICATE_POLICY", "LAST",
+            "LABELS", "code", config.Code.ToLowerInvariant());
+    }
+
+    public async Task<DateOnly> GetNextIngestionDateAsync(IndicatorConfig config, DateOnly today)
+    {
+        try
+        {
+            RedisResult result = await redis.ExecuteAsync("TS.GET", config.RedisKey);
+
+            if (result.IsNull)
+            {
+                return today.AddYears(-10);
+            }
+
+            RedisResult[] parts = (RedisResult[])result!;
+
+            if (parts is null || parts.Length == 0)
+            {
+                return today.AddYears(-10);
+            }
+
+            long lastTimestampMs = (long)parts[0];
+
+            DateOnly lastDate = DateOnly.FromDateTime(
+                DateTimeOffset.FromUnixTimeMilliseconds(lastTimestampMs).DateTime);
+
+            return lastDate.AddDays(1);
+        }
+        catch
+        {
+            return today.AddYears(-10);
+        }
+    }
+
+    public async Task<IEnumerable<Indicator>> GetIndicatorsAsync(string code, DateOnly from, DateOnly to)
+    {
+        RedisResult? timeSeries = await redis.ExecuteAsync(
+            "TS.RANGE",
+            IndicatorConfigs.GetByCode(code).RedisKey,
+            from.ToUnixMilliseconds(),
+            to.ToUnixMilliseconds());
+
+        if (timeSeries.IsNull || timeSeries.Length == 0)
+        {
+            return [];
+        }
+
+        IEnumerable<Indicator> data = IndicatorMapper.Map((RedisResult[])timeSeries!);
+
+        return data;
+    }
+
+    public async Task AppendAsync(IndicatorConfig config, IEnumerable<Indicator> indicators)
+    {
+        Indicator[] arr = indicators as Indicator[] ?? [.. indicators];
+
+        if (arr.Length == 0)
+        {
+            return;
+        }
+
+        object[] args = new object[arr.Length * 3];
+
+        int index = 0;
+
+        foreach (var indicator in arr)
+        {
+            long timestampMs = new DateTimeOffset(indicator.Date.ToDateTime(TimeOnly.MinValue))
+                .ToUnixTimeMilliseconds();
+
+            args[index++] = config.RedisKey;
+            args[index++] = timestampMs;
+            args[index++] = indicator.Value.ToString(CultureInfo.InvariantCulture);
+        }
+
+        await redis.ExecuteAsync("TS.MADD", args);
+    }
+}