public async Task <IActionResult> GetMonthStatistics(
[FromRoute] int year,
[FromRoute] int month,
[FromRoute] Ticker ticker,
[FromRoute] ExchangeTitle exchange)
{
log.Info($"Received a request \"{Request.Path}\"");
if (!DateTimeExtensions.TryParse(year, month, 1, out var selectedDate))
{
log.Warn($"Invalid date {year}/{month}");
return(BadRequest($"Invalid date {year}/{month}"));
}
var result = await manager.ReadForMonthAsync(exchange, ticker, selectedDate).ConfigureAwait(false);
if (result.IsFail)
{
return(NotFound(result.Error));
}
return(Ok(new TradesMonthStatisticsResponse
{
AsksAmount = result.Value.Where(t => t.IsSale).Sum(t => t.Amount),
BidsAmount = result.Value.Where(t => t.IsBuy).Sum(t => t.Amount)
}));
}
private (Trade[], TimeSpan) FilterTrades(ExchangeTitle exchange, Trade[] trades, ILog log)
{
var lastId = State.LastIds[exchange][Ticker.BtcUsd];
var newTrades = trades.Where(t => t.Id > lastId).ToArray();
if (trades.Length != 0 && newTrades.Length == trades.Length)
{
var lostTradesCount = newTrades[0].Id - lastId;
log.Warn($"Got {newTrades.Length}/{trades.Length} new trades (with id bigger than {lastId}). {lostTradesCount} trades are lost");
}
else
{
log.Debug($"Got {newTrades.Length}/{trades.Length} new trades (with id bigger than {lastId})");
}
var result = newTrades.Where(t => t.Amount > State.MinimumAmount).ToArray();
log.Debug($"Got {result.Length}/{newTrades.Length} with amount bigger than {State.MinimumAmount}");
if (newTrades.Length > 0)
{
var maxId = newTrades.Max(t => t.Id);
log.Debug($"New last id is {maxId}");
State.LastIds[exchange][Ticker.BtcUsd] = maxId;
}
if (trades.Length == 0)
{
return(result, TimeSpan.FromSeconds(10));
}
return(result, TimeSpan.FromSeconds(10 * ((trades.Length - newTrades.Length) / (double)trades.Length)));
}
private FileStream GetWriter(DateTime dateTime, ExchangeTitle exchange, Ticker ticker)
{
var filename = GetFilename(dateTime, exchange, ticker);
log.Debug($"Writing to file \"{filename}\"");
return(File.Open(filename, FileMode.Append, FileAccess.Write, FileShare.ReadWrite));
}
private string GetFilename(DateTime dateTime, ExchangeTitle exchange, Ticker ticker)
{
if (!Directory.Exists($"{path}\\{exchange.ToString()}"))
{
log.Debug($"Creating folder for exchange {exchange.ToString()}");
Directory.CreateDirectory($"{path}\\{exchange.ToString()}");
}
return($"{path}\\{exchange.ToString()}\\{exchange.ToString()}_{ticker}_{dateTime:MM_yyyy}");
}
public Result <Timestamp[]> ReadTimestampForDay(DateTime dateTime, ExchangeTitle exchange, Ticker ticker)
{
var readResult = ReadTimestampForMonth(dateTime, exchange, ticker);
if (readResult.IsFail)
{
return(readResult);
}
return(readResult.Value.Where(t => t.Date.Day == dateTime.Day).ToArray());
}
public Result <Timestamp[]> ReadTimestampForMonth(DateTime dateTime, ExchangeTitle exchange, Ticker ticker)
{
var timestamp = ReadInnerTimestampForMonth(dateTime, exchange, ticker);
if (timestamp.IsFail)
{
return(timestamp.Error);
}
return(timestamp.Value.Timestamps);
}
private Dictionary <DateTime, TickerInfo> ReadTicketInfo(DateTime dateTime, ExchangeTitle exchange, Ticker ticker)
{
var filename = GetFilename(dateTime, exchange, ticker);
if (!File.Exists(filename))
{
return(new Dictionary <DateTime, TickerInfo>());
}
var rawData = File.ReadAllBytes(filename);
return(Timestamp.FromBytes(rawData).ToDictionary(k => k.Date, v => v.TickerInfo));
}
public async Task WriteAsync(ExchangeTitle exchange, IEnumerable <Trade> trades, Ticker ticker)
{
var groups = trades.GroupBy(t => t.Time.Day);
foreach (var @group in groups)
{
var groupedTrades = group.ToList();
await using var writer = GetWriter(groupedTrades.First().Time, exchange, ticker);
await writer.WriteAsync(groupedTrades.SelectMany(t => t.ToBytes()).ToArray())
.ConfigureAwait(false);
}
}
public Result <Timestamp[]> ReadTimestampForMonth(DateTime dateTime, ExchangeTitle exchange, Ticker ticker)
{
var filename = GetFilename(dateTime, exchange, ticker);
log.Debug($"Reading timestamp for month from \"{filename}\"");
if (!File.Exists(filename))
{
log.Debug($"No such file \"{filename}\"");
return("No such file");
}
var file = File.ReadAllBytes(filename);
log.Debug($"Read a file with length {file.Length}");
return(Timestamp.FromBytes(file).ToArray());
}
public async Task <Result <Trade[]> > ReadForMonthAsync(ExchangeTitle exchange, Ticker ticker, DateTime month)
{
var filename = GetFilename(month, exchange, ticker);
log.Debug($"Reading trades for month from \"{filename}\"");
if (!File.Exists(filename))
{
log.Debug($"No such file \"{filename}\"");
return("No such file");
}
var file = await File.ReadAllBytesAsync(filename).ConfigureAwait(false);
log.Debug($"Read a file with length {file.Length}");
return(Trade.FromBytes(file).ToArray());
}
public void ShowExchange()
{
List <RechargeModel> listType = new List <RechargeModel>();
foreach (RechargeModel model in GameManager.Instance.ListRechargeModel)
{
if (listType.Count == 0)
{
listType.Add(model);
}
else
{
if (listType.Find(m => m.Type == model.Type) == null)
{
listType.Add(model);
}
}
}
ExchangeTitle.Create("sms", exchangeGrid.transform).transform.name = "1";
List <RechargeModel> smsRecharge = GameManager.Instance.ListRechargeModel.FindAll(m => m.Type == "sms");
for (int j = 0; j < smsRecharge.Count; j++)
{
ItemExchange.Create(smsRecharge[j], exchangeGrid.transform).transform.name = "1." + j;
}
ExchangeTitle.Create("mobile_card", exchangeGrid.transform).transform.name = "2";
List <List <RechargeModel> > lstGroup = GroupCardCodeValue();
for (int j = 0; j < lstGroup.Count; j++)
{
ItemExchange.Create(lstGroup[j][0], exchangeGrid.transform).transform.name = "2." + j;
}
exchangeGrid.repositionNow = true;
exchangeGrid.transform.parent.GetComponent <UIScrollView> ().ResetPosition();
}
public ActionResult GetTimestamp(
[FromRoute] int year,
[FromRoute] int month,
[FromRoute] int day,
[FromRoute] Ticker ticker,
[FromRoute] ExchangeTitle exchange,
[FromQuery] int precision = -1)
{
log.Info($"Received a request \"{Request.Path}\"");
if (!DateTimeExtensions.TryParse(year, month, day, out var selectedDate))
{
log.Warn($"Invalid date {year}/{month}/{day}");
return(BadRequest($"Invalid date {year}/{month}/{day}"));
}
var timestamp = timestampManager.ReadTimestampForDay(selectedDate, exchange, ticker);
if (timestamp.IsFail)
{
log.Info($"No timestamps for {year}/{month}/{day}");
return(NotFound($"No timestamps for {year}/{month}/{day}"));
}
// if precision == 0 skip
var byteData = timestamp.Value
.Select(t => new Timestamp(t.Date, new TickerInfo(
t.TickerInfo.AveragePrice,
new OrderBook(t.TickerInfo.OrderBook.Bids.Flat(precision, true).ToArray(),
t.TickerInfo.OrderBook.Asks.Flat(precision, false).ToArray()),
t.TickerInfo.DateTime)))
.Select(t => t.ToBytes2()).SelectMany(t => t).ToArray();
log.Info($"Found timestamps for {year}/{month}/{day}: " +
$"Timestamps count \"{timestamp.Value.Length}\". Byte data length: {byteData.Length}");
return(File(byteData, "application/btd", "data.btd"));
}
public async Task <IActionResult> GetTrades(
[FromRoute] int year,
[FromRoute] int month,
[FromRoute] Ticker ticker,
[FromRoute] ExchangeTitle exchange)
{
log.Info($"Received a request \"{Request.Path}\"");
if (!DateTimeExtensions.TryParse(year, month, 1, out var selectedDate))
{
log.Warn($"Invalid date {year}/{month}");
return(BadRequest($"Invalid date {year}/{month}"));
}
var result = await manager.ReadForMonthAsync(exchange, ticker, selectedDate).ConfigureAwait(false);
if (result.IsFail)
{
return(NotFound(result.Error));
}
return(Ok(result.Value.Select(TradeResponse.FromTrade)));
}
public async Task <Trade[]> GetCurrentTradeListsAsync(ExchangeTitle exchange, Ticker ticker)
{
var result = await exchangeClients[exchange].GetLastTradesAsync(ticker).ConfigureAwait(false);
return(result.IsSuccess ? result.Value : new Trade[0]);
}
private Result <MonthTimestamp> ReadInnerTimestampForMonth(DateTime dateTime, ExchangeTitle exchange, Ticker ticker)
{
var key = new TimestampKey {
Year = dateTime.Year, Month = dateTime.Month, Exchange = exchange, Ticker = ticker
};
if (dateTime.Date != DateTime.Today && buffer.TryGetValue(key, out var buffered))
{
return(buffered);
}
var timestamp = innerManager.ReadTimestampForMonth(dateTime, exchange, ticker);
if (timestamp.IsFail)
{
return("No timestamp");
}
var monthTimestamp = new MonthTimestamp(dateTime, exchange, ticker, timestamp.Value);
buffer[key] = monthTimestamp;
return(monthTimestamp);
}
