private async Task CatchupAsync(Candle lastDbCandle)
{
var maxPoints = _exchange.ExchangeConfig.UserConfig.MaxDataPoints;
var now = _exchange.Now;
var dataPoints = lastDbCandle != null
? ExchangeUtils.GetDataPointsFromTimeSpan(_period, now - lastDbCandle.Timestamp.ToUniversalTime())
: maxPoints;
if (dataPoints <= 0)
{
return;
}
if (dataPoints > maxPoints)
{
dataPoints = maxPoints;
}
var candles = await _exchange.GetCandlesAsync(_instrument, _period, ExchangeUtils.GetTimeOffsetFromDataPoints(_period, now, dataPoints), now);
if (candles != null)
{
await InsertCandlesAsync(candles.ToArray());
}
var lastEntryLogText = (lastDbCandle != null ? $"was last seen at {lastDbCandle.Timestamp.ToUniversalTime()}" : "has no pevious records");
_logger.Log(LogLevel.Info, $"{_exchangeName} {_instrument} {_period} {lastEntryLogText}");
var syncStatusText = (dataPoints > 0 ? $"{dataPoints} data points behind" : "up to date");
_logger.Log(LogLevel.Info, $"{_exchangeName} {_instrument} {_period} is {syncStatusText}");
}
private Task OnNewTrade(TradeDto[] arg)
{
if (arg == null || !arg.Any())
{
return(Task.CompletedTask);
}
var last = arg.Last();
var timePeriods = Enum.GetValues(typeof(TimePeriod)).Cast <TimePeriod>().ToArray();
foreach (var period in timePeriods)
{
var key = ExchangeUtils.GetCandleDataKey(last.ExchangeName, last.Instrument, period);
if (!_exchangeCandles.ContainsKey(key))
{
continue;
}
_exchangeCandles[key].UpdateCurrentCandle(last.Price, arg.Length, arg.Sum(x => x.Size));
}
return(Task.CompletedTask);
}
private async Task ListenAsync()
{
try
{
while (_client.State == WebSocketState.Open && !_cancellationToken.IsCancellationRequested)
{
WebSocketReceiveResult result = null;
var buffer = new byte[1000];
var message = new ArraySegment <byte>(buffer);
var response = new StringBuilder();
while (result == null || !result.EndOfMessage)
{
result = await _client.ReceiveAsync(message, _cancellationToken);
response.Append(ExchangeUtils.DecodeText(buffer, result.Count, _encodingType));
if (result.MessageType != WebSocketMessageType.Text)
{
break;
}
}
var responseText = response.ToString();
await _onReceive.Invoke(responseText);
}
}
catch (Exception e)
{
Console.WriteLine(e);
throw;
}
}
public async Task SendAsync(string message)
{
var buffer = ExchangeUtils.EncodeText(message, _encodingType);
var messageSegment = new ArraySegment <byte>(buffer);
await _client.SendAsync(messageSegment, WebSocketMessageType.Text, true, _cancellationToken);
}
private ExchangeCandles GetData(string exchangeName, Instrument instrument, TimePeriod period)
{
var key = ExchangeUtils.GetCandleDataKey(exchangeName, instrument, period);
return(_exchangeCandles.ContainsKey(key)
? _exchangeCandles[key]
: null);
}
private void ResetCurrentCandle(CandleDto latest)
{
CurrentCandle.Open = latest.Close;
CurrentCandle.High = latest.Close;
CurrentCandle.Low = latest.Close;
CurrentCandle.Trades = 0;
CurrentCandle.Volume = 0;
CurrentCandle.Timestamp = ExchangeUtils.GetTimeOffsetFromDataPoints(latest.Period, CurrentCandle.Timestamp, -1);
}
private async Task OnNewCandle(CandleDto[] arg)
{
if (arg == null || !arg.Any())
{
return;
}
var last = arg.Last();
var key = ExchangeUtils.GetCandleDataKey(last.ExchangeName, last.Instrument, last.Period);
if (!_exchangeCandles.ContainsKey(key))
{
return;
}
await _exchangeCandles[key].InsertCandlesAsync(arg);
}
private async Task OnPositionUpdate(PositionDto[] positions)
{
if (positions == null || !positions.Any())
{
return;
}
var exchangeName = positions.First().ExchangeName;
if (!_exchangePositions.ContainsKey(exchangeName))
{
return;
}
var exchangePosition = _exchangePositions[exchangeName];
foreach (var position in positions)
{
if (exchangePosition.ContainsKey(position.Instrument))
{
exchangePosition[position.Instrument] = Mapper.Map(position, exchangePosition[position.Instrument]);
}
else
{
exchangePosition.Add(position.Instrument, position);
}
var key = ExchangeUtils.GetExchangePositionKey(exchangeName, position.Instrument);
if (!_positionCallbacks.ContainsKey(key))
{
continue;
}
var callbacks = _positionCallbacks[key];
foreach (var callback in callbacks)
{
await callback.Invoke(exchangePosition[position.Instrument]);
}
}
}
