docker files fixes from liaqat

src/Managing.Infrastructure.Database/InfluxDb/Abstractions/IInfluxDbRepository.cs

@@ -0,0 +1,11 @@
+using InfluxDB.Client;
+
+namespace Managing.Infrastructure.Databases;
+
+public interface IInfluxDbRepository
+{
+    string Organization { get; }
+
+    Task<T> QueryAsync<T>(Func<QueryApi, Task<T>> action);
+    void Write(Action<WriteApi> action);
+}

src/Managing.Infrastructure.Database/InfluxDb/Abstractions/IInfluxDbSettings.cs

@@ -0,0 +1,8 @@
+namespace Managing.Infrastructure.Databases.Abstractions;
+
+public interface IInfluxDbSettings
+{
+    string Url { get; set; }
+    string Token { get; set; }
+    string Organization { get; set; }
+}

src/Managing.Infrastructure.Database/InfluxDb/InfluxDbRepository.cs

@@ -0,0 +1,32 @@
+using InfluxDB.Client;
+using Managing.Infrastructure.Databases.Abstractions;
+
+namespace Managing.Infrastructure.Databases.InfluxDb;
+
+public class InfluxDbRepository : IInfluxDbRepository
+{
+    private readonly string _token;
+    private readonly string _url;
+    public string Organization { get; set; }
+
+    public InfluxDbRepository(IInfluxDbSettings settings)
+    {                                                                                                                                                                            
+        _token = settings.Token;
+        _url = settings.Url;
+        Organization = settings.Organization;
+    }
+
+    public void Write(Action<WriteApi> action)
+    {
+        using var client = InfluxDBClientFactory.Create(_url, _token);
+        using var write = client.GetWriteApi();
+        action(write);
+    }
+
+    public async Task<T> QueryAsync<T>(Func<QueryApi, Task<T>> action)
+    {
+        using var client = InfluxDBClientFactory.Create(_url, _token);
+        var query = client.GetQueryApi();
+        return await action(query);
+    }
+}

src/Managing.Infrastructure.Database/InfluxDb/Models/InfluxDbSettings.cs

@@ -0,0 +1,10 @@
+using Managing.Infrastructure.Databases.Abstractions;
+
+namespace Managing.Infrastructure.Databases.InfluxDb.Models;
+
+public class InfluxDbSettings : IInfluxDbSettings
+{
+    public string Url { get ; set; }
+    public string Token { get; set; }
+    public string Organization { get; set; }
+}

src/Managing.Infrastructure.Database/InfluxDb/Models/PriceDto.cs

@@ -0,0 +1,36 @@
+using InfluxDB.Client.Core;
+
+namespace Managing.Infrastructure.Databases.InfluxDb.Models;
+
+[Measurement("price")]
+public class PriceDto
+{
+    [Column("exchange", IsTag = true)]
+    public string Exchange { get; set; }
+    [Column("ticker", IsTag = true)]
+    public string Ticker { get; set; }
+    [Column("timeframe", IsTag = true)]
+    public string Timeframe { get; set; }
+    [Column("openTime", IsTimestamp = true)]
+    public DateTime OpenTime { get; set; }
+    [Column("closeTime", IsTimestamp = true)]
+    public DateTime CloseTime { get; set; }
+    [Column("open")]
+    public decimal Open { get; set; }
+    [Column("close")]
+    public decimal Close { get; set; }
+    [Column("high")]
+    public decimal High { get; set; }
+    [Column("low")]
+    public decimal Low { get; set; }
+    [Column("baseVolume")]
+    public decimal BaseVolume { get; set; }
+    [Column("quoteVolume")]
+    public decimal QuoteVolume { get; set; }
+    [Column("TradeCount")]
+    public int TradeCount { get; set; }
+    [Column("takerBuyBaseVolume")]
+    public decimal TakerBuyBaseVolume { get; set; }
+    [Column("takerBuyQuoteVolume")]
+    public decimal TakerBuyQuoteVolume { get; set; }
+}

src/Managing.Infrastructure.Database/InfluxDb/Models/TickerDto.cs

@@ -0,0 +1 @@
+

src/Managing.Infrastructure.Database/InfluxDb/PriceHelpers.cs

@@ -0,0 +1,58 @@
+using Managing.Core;
+using Managing.Domain.Candles;
+using Managing.Infrastructure.Databases.InfluxDb.Models;
+using static Managing.Common.Enums;
+
+namespace Managing.Infrastructure.Databases.InfluxDb;
+
+public static class PriceHelpers
+{
+    public static PriceDto Map(Candle candle)
+    {
+        var price = new PriceDto
+        {
+            Exchange = candle.Exchange.ToString(),
+            Ticker = candle.Ticker,
+            OpenTime = candle.OpenTime.ToUniversalTime(),
+            Open = candle.Open,
+            Close = candle.Close,
+            CloseTime = candle.Date.ToUniversalTime(),
+            High = candle.High,
+            Low = candle.Low,
+            BaseVolume = candle.BaseVolume,
+            QuoteVolume = candle.QuoteVolume,
+            TradeCount = candle.TradeCount,
+            TakerBuyBaseVolume = candle.TakerBuyBaseVolume,
+            TakerBuyQuoteVolume = candle.TakerBuyQuoteVolume,
+            Timeframe = candle.Timeframe.ToString()
+        };
+
+        return price;
+    }
+
+    public static Candle Map(PriceDto dto)
+    {
+        return new Candle
+        {
+            Exchange = MiscExtensions.ParseEnum<TradingExchanges>(dto.Exchange),
+            Ticker = dto.Ticker,
+            OpenTime = dto.OpenTime,
+            Open = dto.Open,
+            Close = dto.Close,
+            Date = dto.CloseTime,
+            High = dto.High,
+            Low = dto.Low,
+            BaseVolume = dto.BaseVolume,
+            QuoteVolume = dto.QuoteVolume,
+            TradeCount = dto.TradeCount,
+            TakerBuyBaseVolume = dto.TakerBuyBaseVolume,
+            TakerBuyQuoteVolume = dto.TakerBuyQuoteVolume,
+            Timeframe = MiscExtensions.ParseEnum<Timeframe>(dto.Timeframe)
+        };
+    }
+
+    internal static IEnumerable<PriceDto> Map(IEnumerable<Candle> candles)
+    {
+        return candles.Select(candle => Map(candle));
+    }
+}