public async Task <ICollection <MarketTradeStat> > GetNextTradeStats(ExchangeEnum exchange, SymbolCodeEnum symbolCode, ExchangeStatsKeyEnum statKey, long tradeStatId, int limit = 1)
{
using (var context = ContextFactory.CreateDbContext(null))
{
var tradeStats = context.ExchangeTradeStat
.Where(t => t.ExchangeId == (int)exchange && t.SymbolId == (int)symbolCode && t.StatKeyId == (int)statKey && t.TradeStatId > tradeStatId)
.OrderBy(t => t.TradeStatId)
.Take(limit)
.Select(t => new
{
Exchange = exchange,
SymbolCode = symbolCode,
StatKey = statKey,
Timestamp = t.Timestamp,
TradeStatId = (long)t.TradeStatId,
Value = t.Value
});
var raw = await tradeStats.ToListAsync();
return(raw.Select(t => new MarketTradeStat
{
Exchange = t.Exchange,
SymbolCode = t.SymbolCode,
StatKey = t.StatKey,
Epoch = Epoch.FromMilliseconds(t.Timestamp),
TradeStatId = t.TradeStatId,
Value = t.Value
}).ToList());
}
}
public async Task <ICollection <MarketTrade> > GetNextTrades(ExchangeEnum exchange, SymbolCodeEnum symbolCode, Epoch from, long tradeId, int limit = 1)
{
using (var context = ContextFactory.CreateDbContext(null))
{
var trades = context.ExchangeTrade
.Where(t => t.ExchangeId == (int)exchange && t.SymbolId == (int)symbolCode && t.Timestamp >= from.TimestampMilliseconds && t.TradeId > tradeId)
.OrderBy(t => t.TradeId)
.Take(limit)
.Select(t => new
{
Exchange = exchange,
SymbolCode = symbolCode,
Timestamp = t.Timestamp,
TradeId = (long)t.TradeId,
Side = t.OrderSideId.HasValue ? (OrderSideEnum)t.OrderSideId : (OrderSideEnum?)null,
Price = t.Price,
Volume = t.Volume
});
var raw = await trades.ToListAsync();
return(raw.Select(t => new MarketTrade
{
Exchange = t.Exchange,
SymbolCode = t.SymbolCode,
Epoch = Epoch.FromMilliseconds(t.Timestamp),
TradeId = t.TradeId,
Side = t.Side,
Price = t.Price,
Volume = t.Volume
}).ToList());
}
}
public async Task <PagedCollection <MarketTrade> > GetTrades(ExchangeEnum exchange, SymbolCodeEnum symbolCode, Epoch from, Epoch to, int?pageSize, int?pageNumber)
{
using (var context = ContextFactory.CreateDbContext(null))
{
var query =
from
t
in
context.ExchangeTrade
where
t.ExchangeId == (int)exchange &&
t.SymbolId == (int)symbolCode &&
t.Timestamp >= @from.TimestampMilliseconds &&
t.Timestamp <= to.TimestampMilliseconds
select new
{
Exchange = exchange,
SymbolCode = symbolCode,
Timestamp = t.Timestamp,
TradeId = t.TradeId,
Side = t.OrderSideId.HasValue ? (OrderSideEnum)t.OrderSideId : (OrderSideEnum?)null,
Price = t.Price,
Volume = t.Volume
};
var totalCount = 0;
if (pageSize.HasValue)
{
totalCount = await query.CountAsync();
query = query.Skip(pageNumber.GetValueOrDefault(0) * pageSize.Value).Take(pageSize.Value);
}
var trades = await query.ToListAsync();
return(new PagedCollection <MarketTrade>()
{
PageNumber = pageNumber.GetValueOrDefault(0),
PageSize = pageSize.GetValueOrDefault(0),
ItemCount = pageSize.HasValue ? totalCount : trades.Count,
Items = trades.Select(t => new MarketTrade
{
Exchange = t.Exchange,
SymbolCode = t.SymbolCode,
Epoch = Epoch.FromMilliseconds(t.Timestamp),
TradeId = t.TradeId,
Side = t.Side,
Price = t.Price,
Volume = t.Volume
}).ToList()
});
}
}
public async Task <PagedCollection <MarketAggregate> > GetTradeAggregates(ExchangeEnum exchange, SymbolCodeEnum symbolCode, IntervalKey intervalKey, Epoch from, Epoch to, int?pageSize, int?pageNumber)
{
var intervals = IntervalFactory.GenerateIntervals(intervalKey, from, to);
var min = intervals.First();
var max = intervals.Last();
using (var context = ContextFactory.CreateDbContext(null))
{
var query = context.ExchangeTradeAggregate
.Where(a => a.ExchangeId == (int)exchange && a.SymbolId == (int)symbolCode && a.IntervalKey == intervalKey.Key && a.Timestamp >= min.From.TimestampMilliseconds && a.Timestamp <= max.From.TimestampMilliseconds);
var totalCount = 0;
if (pageSize.HasValue)
{
totalCount = await query.CountAsync();
query = query.Skip(pageNumber.GetValueOrDefault(0) * pageSize.Value).Take(pageSize.Value);
}
var aggs = await query.ToListAsync();
return(new PagedCollection <MarketAggregate>()
{
PageNumber = pageNumber.GetValueOrDefault(0),
PageSize = pageSize.GetValueOrDefault(0),
ItemCount = pageSize.HasValue ? totalCount : aggs.Count,
Items = aggs.Select(a => new MarketAggregate
{
Exchange = exchange,
Symbol = symbolCode,
IntervalKey = a.IntervalKey,
Epoch = Epoch.FromMilliseconds(a.Timestamp),
Open = a.Open,
OpenEpoch = Epoch.FromMilliseconds(a.OpenTimestamp),
High = a.High,
Low = a.Low,
Close = a.Close,
CloseEpoch = Epoch.FromMilliseconds(a.CloseTimestamp),
BuyVolume = a.BuyVolume,
SellVolume = a.SellVolume,
TotalVolume = a.TotalVolume,
BuyCount = a.BuyCount,
SellCount = a.SellCount,
TotalCount = a.TotalCount
}).ToList()
});
}
}
public async Task <HistorianTradeCatchup> GetNextTradeCatchup(ExchangeEnum exchange, SymbolCodeEnum symbolCode)
{
using (var context = ContextFactory.CreateDbContext(null))
{
var next = await context.HistorianTradeCatchup
.Where(c => c.ExchangeId == (int)exchange && c.SymbolId == (int)symbolCode)
.OrderByDescending(c => c.TimestampTo)
.OrderBy(c => c.Priority)
.FirstOrDefaultAsync();
return(next != null ?
new HistorianTradeCatchup
{
Exchange = (ExchangeEnum)next.ExchangeId,
SymbolCode = (SymbolCodeEnum)next.SymbolId,
TradeFilter = next.TradeFilter,
EpochTo = Epoch.FromMilliseconds(next.TimestampTo),
CurrentTradeFilter = next.CurrentTradeFilter,
Priority = next.Priority
} : null);
}
}
public static T2 ChangeType <T, T2>(this Bitfinex exchange, ISymbolFactory symbolFactory, T obj, NameValueCollection query, NameValueCollection additionalData)
{
if (typeof(T2) == typeof(ICollection <MarketTick>))
{
var ticks = obj as List <object[]>;
return((T2)(object)ticks.Select(t => new MarketTick
{
Exchange = exchange.Name,
Epoch = new Epoch(DateTime.UtcNow),
SymbolCode = symbolFactory.Get(exchange.DecodeSymbol(t[0].ToString())[0], exchange.DecodeSymbol(t[0].ToString())[1]).Code,
BuyPrice = Convert.ToDecimal(t[1]),
SellPrice = Convert.ToDecimal(t[3]),
LastPrice = Convert.ToDecimal(t[7])
}).ToList());
}
if (typeof(T2) == typeof(MarketTick))
{
var tick = obj as object[];
var symbolCode = (SymbolCodeEnum)Enum.Parse(typeof(SymbolCodeEnum), additionalData["SymbolCode"]);
return((T2)(object)new MarketTick
{
Exchange = exchange.Name,
Epoch = new Epoch(DateTime.UtcNow),
SymbolCode = symbolCode,
BuyPrice = Convert.ToDecimal(tick[0]),
SellPrice = Convert.ToDecimal(tick[2]),
LastPrice = Convert.ToDecimal(tick[6])
});
}
if (typeof(T2) == typeof(TradeResult))
{
var trades = obj as JArray;
var filter = trades.Count > 0 ? Convert.ToString(trades.Max(t => t[1])) : query["start"];
var symbolCode = (SymbolCodeEnum)Enum.Parse(typeof(SymbolCodeEnum), additionalData["SymbolCode"]);
return((T2)(object)new TradeResult
{
Exchange = exchange.Name,
SymbolCode = symbolCode,
Trades = trades.Select(t => new MarketTrade
{
Exchange = exchange.Name,
SymbolCode = symbolCode,
Epoch = Epoch.FromMilliseconds(Convert.ToInt64(t[1])),
Price = Convert.ToDecimal(t[3]),
Volume = Math.Abs(Convert.ToDecimal(t[2])),
Side = Convert.ToDecimal(t[2]) > 0 ? OrderSideEnum.Buy : OrderSideEnum.Sell,
SourceTradeId = Convert.ToString(t[0])
}).OrderBy(t => t.Epoch.TimestampMilliseconds).ThenBy(t => t.SourceTradeId).ToList(),
Filter = filter
});
}
if (typeof(T2) == typeof(ICollection <ExchangeStats>))
{
var tradeStats = (obj as List <BitfinexMarketStats>);
var statKey = (ExchangeStatsKeyEnum)Enum.Parse(typeof(ExchangeStatsKeyEnum), additionalData["StatKey"]);
var symbolCode = (SymbolCodeEnum)Enum.Parse(typeof(SymbolCodeEnum), additionalData["SymbolCode"]);
return((T2)(object)tradeStats.Select(t => new ExchangeStats
{
Exchange = exchange.Name,
SymbolCode = symbolCode,
StatKey = statKey,
Epoch = Epoch.FromMilliseconds(Convert.ToInt64(t[0])),
Value = Convert.ToDecimal(t[1])
}).ToList());
}
if (typeof(T) == typeof(T2))
{
return((T2)(object)obj);
}
throw new Exception("Invalid type provided - " + typeof(T2));
}
public static T2 ChangeType <T, T2>(this Binance exchange, ICurrencyFactory currencyFactory, ISymbolFactory symbolFactory, NameValueCollection postData, T obj)
{
if (typeof(T) == typeof(ICollection <BinancePriceTicker>))
{
var ticks = new List <MarketTick>();
var priceTicks = obj as ICollection <BinancePriceTicker>;
foreach (var tick in priceTicks)
{
var binanceSymbol = exchange.Info.Symbols.Where(x => x.Symbol == tick.Symbol).FirstOrDefault();
var baseCurrencyCode = exchange.GetStandardisedCurrencyCode(currencyFactory, binanceSymbol.BaseAsset);
var quoteCurrencyCode = exchange.GetStandardisedCurrencyCode(currencyFactory, binanceSymbol.QuoteAsset);
var symbol = symbolFactory.Get(baseCurrencyCode, quoteCurrencyCode);
ticks.Add(new MarketTick
{
Exchange = exchange.Name,
SymbolCode = symbol.Code,
Epoch = Epoch.Now,
LastPrice = tick.Price,
});
}
return((T2)(object)ticks);
}
if (typeof(T) == typeof(ICollection <BinanceOrderBookTicker>))
{
var ticks = new List <MarketTick>();
var bookTicks = (obj as ICollection <BinanceOrderBookTicker>);
foreach (var tick in bookTicks)
{
var binanceSymbol = exchange.Info.Symbols.Where(x => x.Symbol == tick.Symbol).FirstOrDefault();
var baseCurrencyCode = exchange.GetStandardisedCurrencyCode(currencyFactory, binanceSymbol.BaseAsset);
var quoteCurrencyCode = exchange.GetStandardisedCurrencyCode(currencyFactory, binanceSymbol.QuoteAsset);
var symbol = symbolFactory.Get(baseCurrencyCode, quoteCurrencyCode);
ticks.Add(new MarketTick
{
Exchange = exchange.Name,
SymbolCode = symbol.Code,
Epoch = Epoch.Now,
BuyPrice = tick.AskPrice,
SellPrice = tick.BidPrice
});
}
return((T2)(object)ticks);
}
if (typeof(T2) == typeof(TradeResult))
{
var trades = obj as ICollection <Dictionary <string, object> >;
var filter = trades.Count > 0 ? trades.Last()["a"].ToString() : postData["fromId"];
var binanceSymbol = exchange.Info.Symbols.Where(x => x.Symbol == postData["symbol"]).FirstOrDefault();
var baseCurrencyCode = exchange.GetStandardisedCurrencyCode(currencyFactory, binanceSymbol.BaseAsset);
var quoteCurrencyCode = exchange.GetStandardisedCurrencyCode(currencyFactory, binanceSymbol.QuoteAsset);
var symbol = symbolFactory.Get(baseCurrencyCode, quoteCurrencyCode);
return((T2)(object)new TradeResult
{
Exchange = exchange.Name,
SymbolCode = symbol.Code,
Trades = trades.Select(t => new MarketTrade
{
Exchange = exchange.Name,
SymbolCode = symbol.Code,
Epoch = Epoch.FromMilliseconds(Convert.ToInt64(t["T"])),
Price = Convert.ToDecimal(t["p"]),
Volume = Convert.ToDecimal(t["q"]),
Side = Convert.ToBoolean(t["m"]) ? OrderSideEnum.Sell : OrderSideEnum.Buy,
SourceTradeId = Convert.ToString(t["a"])
}).ToList(),
Filter = filter
});
}
if (typeof(T) == typeof(ICollection <BinanceTradeItem>))
{
var binanceSymbol = exchange.Info.Symbols.Where(x => x.Symbol == postData["symbol"]).FirstOrDefault();
var baseCurrencyCode = exchange.GetStandardisedCurrencyCode(currencyFactory, binanceSymbol.BaseAsset);
var quoteCurrencyCode = exchange.GetStandardisedCurrencyCode(currencyFactory, binanceSymbol.QuoteAsset);
var symbol = symbolFactory.Get(baseCurrencyCode, quoteCurrencyCode);
var trades = obj as ICollection <BinanceTradeItem>;
return((T2)(object)trades.Select(t => new TradeItem
{
Exchange = exchange.Name,
SymbolCode = symbol.Code,
Created = Epoch.FromMilliseconds(t.Time),
Id = t.Id.ToString(),
OrderId = t.OrderId.ToString(),
Fee = t.Commission,
FeeCurrencyCode = exchange.GetStandardisedCurrencyCode(currencyFactory, t.CommissionAsset),
Price = t.Price,
Volume = t.Quantity,
Side = t.IsBuyer ? OrderSideEnum.Buy : OrderSideEnum.Sell
}).ToList());
}
if (typeof(T) == typeof(BinanceNewOrder))
{
var binanceSymbol = exchange.Info.Symbols.Where(x => x.Symbol == postData["symbol"]).FirstOrDefault();
var baseCurrencyCode = exchange.GetStandardisedCurrencyCode(currencyFactory, binanceSymbol.BaseAsset);
var quoteCurrencyCode = exchange.GetStandardisedCurrencyCode(currencyFactory, binanceSymbol.QuoteAsset);
var symbol = symbolFactory.Get(baseCurrencyCode, quoteCurrencyCode);
var newOrder = obj as BinanceNewOrder;
var orderType = exchange.GetOrderType(newOrder.Type);
var price = orderType == OrderTypeEnum.Limit ? newOrder.Price : newOrder.Fills.Average(f => f.Price);
return((T2)(object)new CreateOrder
{
Exchange = exchange.Name,
SymbolCode = symbol.Code,
Id = newOrder.OrderId,
Side = exchange.GetOrderSide(newOrder.Side),
Type = orderType,
State = exchange.GetOrderState(newOrder.Status),
OrderEpoch = Epoch.FromMilliseconds(newOrder.TransactTime),
Price = price,
Volume = newOrder.OriginalQuantity
});
}
if (typeof(T) == typeof(ICollection <BinanceOpenOrder>))
{
var binanceSymbol = exchange.Info.Symbols.Where(x => x.Symbol == postData["symbol"]).FirstOrDefault();
var baseCurrencyCode = exchange.GetStandardisedCurrencyCode(currencyFactory, binanceSymbol.BaseAsset);
var quoteCurrencyCode = exchange.GetStandardisedCurrencyCode(currencyFactory, binanceSymbol.QuoteAsset);
var symbol = symbolFactory.Get(baseCurrencyCode, quoteCurrencyCode);
var openOrders = obj as ICollection <BinanceOpenOrder>;
return((T2)(object)openOrders.Select(o => new OrderItem
{
Exchange = exchange.Name,
SymbolCode = symbol.Code,
Id = o.OrderId,
Side = exchange.GetOrderSide(o.Side),
Type = exchange.GetOrderType(o.Type),
State = exchange.GetOrderState(o.Status),
OrderEpoch = Epoch.FromMilliseconds(o.Time),
Price = o.Price,
AvgPrice = o.Price,
Volume = o.OriginalQuantity,
RemainingVolume = o.OriginalQuantity - o.ExecutedQuantity
}).ToList());
}
if (typeof(T) == typeof(BinanceCancelOrder))
{
var cancelOrder = obj as BinanceCancelOrder;
return((T2)(object)new CancelOrder
{
Exchange = exchange.Name,
Id = cancelOrder.OrderId,
Epoch = Epoch.FromMilliseconds(cancelOrder.TransactTime),
State = exchange.GetOrderState(cancelOrder.Status)
});
}
if (typeof(T) == typeof(T2))
{
return((T2)(object)obj);
}
throw new Exception("Invalid type provided - " + typeof(T2));
}