public async Task <IActionResult> GetTickers([FromQuery] string[] assetPairIds)
{
var entities = _tickersReader.Get(TickerEntity.GetPk());
List <TickerModel> result;
if (entities.Any())
{
result = _mapper.Map <List <TickerModel> >(entities);
}
else
{
var marketData = await _marketDataClient.GetMarketDataAsync(new Empty());
result = _mapper.Map <List <TickerModel> >(marketData.Items.ToList());
}
if (assetPairIds.Any())
{
result = result.Where(x =>
assetPairIds.Contains(x.AssetPairId, StringComparer.InvariantCultureIgnoreCase))
.ToList();
}
return(Ok(ResponseModel <IReadOnlyCollection <TickerModel> > .Ok(result)));
}
public override async Task <TickersResponse> GetTickers(TickersRequest request, ServerCallContext context)
{
var entities = _tickersReader.Get(TickerEntity.GetPk());
List <TickerUpdate> result;
if (entities.Any())
{
result = _mapper.Map <List <TickerUpdate> >(entities);
}
else
{
var marketData = await _marketDataClient.GetMarketDataAsync(new Empty());
result = _mapper.Map <List <TickerUpdate> >(marketData.Items.ToList());
}
if (request.AssetPairIds.Any())
{
result = result.Where(x =>
request.AssetPairIds.Contains(x.AssetPairId, StringComparer.InvariantCultureIgnoreCase))
.ToList();
}
var response = new TickersResponse();
response.Payload.AddRange(result);
return(response);
}
public List <TickerEntity> LoadTickerFromCSV(string path)
{
using (var reader = new StreamReader(path))
using (var csv = new CsvReader(reader, CultureInfo.InvariantCulture))
{
var tickers = new List <TickerEntity>();
// csv.Read();
while (csv.Read())
{
try
{
var ticker = new TickerEntity();
ticker.T = csv.GetField <string>(0);
ticker.P = csv.GetField <int>(1);
ticker.O = csv.GetField <float>(2);
ticker.H = csv.GetField <float>(3);
ticker.L = csv.GetField <float>(4);
ticker.C = csv.GetField <float>(5);
ticker.V = csv.GetField <long>(6);
tickers.Add(ticker);
}
catch (Exception ex)
{
Console.WriteLine($"Error load csv {ex.Message}, path: {path}");
}
}
return(tickers);
}
}
public List <TickerEntity> GetWeeklyTickerListFromDayList(List <TickerEntity> dayTickerList)
{
List <TickerEntity> weeklyTickerList = new List <TickerEntity>();
Dictionary <int, List <TickerEntity> > tickerDict = new Dictionary <int, List <TickerEntity> >();
foreach (TickerEntity ticker in dayTickerList)
{
int beginOfWeek = DateHelper.BeginOfWeek(ticker.P);
if (!tickerDict.ContainsKey(beginOfWeek))
{
tickerDict.Add(beginOfWeek, new List <TickerEntity>());
}
tickerDict[beginOfWeek].Add(ticker);
}
foreach (var item in tickerDict)
{
TickerEntity weeklyTicker = this.GetWeeklyTickerFromDayList(item.Key, item.Value);
if (weeklyTicker != null)
{
weeklyTickerList.Add(weeklyTicker);
}
}
return(weeklyTickerList);
}
public async Task Update(TickerEntity ticker)
{
Document updatedAccountDoc = null;
Document accountDoc = this.toTickerDocument(ticker);
updatedAccountDoc = await this.table.UpdateItemAsync(accountDoc);
return;
}
public async Task <JsonResult> GetTicker_Ripple_Success()
{
TickerEntity ticker = await _client.GetTickerAsync("ripple", ConvertEnum.USD);
// Assert.IsNotNull(ticker);
//Assert.Greater(ticker.Name, "ripple");
//Assert.Greater(ticker.PriceOther[Enums.ConvertEnum.USD], 0);
//Assert.Less(ticker.LastUpdated, DateTime.Now);
return(Json(ticker, JsonRequestBehavior.AllowGet));
}
public Coin(string s, TickerEntity t)
{
float value = 0;
if (float.TryParse(s, out value))
{
Count = value;
Ticker = t;
Time = new MyDateTime();
}
}
private Document toTickerDocument(TickerEntity ticker)
{
var doc = new Document();
doc["code"] = ticker.T;
doc["p"] = ticker.P;
doc["o"] = ticker.O;
doc["h"] = ticker.H;
doc["c"] = ticker.C;
doc["l"] = ticker.L;
doc["v"] = ticker.V;
return(doc);
}
private TickerEntity toTickerEntity(Document doc)
{
TickerEntity en = null;
if (doc != null)
{
en = new TickerEntity();
en.T = doc["code"].ToString();
en.P = doc["p"].AsInt();
en.O = (float)doc["o"].AsDecimal();
en.H = (float)doc["h"].AsDecimal();
en.L = (float)doc["l"].AsDecimal();
en.C = (float)doc["c"].AsDecimal();
en.V = doc["v"].AsLong();
}
return(en);
}
public TickerEntity GetWeeklyTickerFromDayList(int period, List <TickerEntity> dayTickerList)
{
TickerEntity weeklyTicker = null;
if (dayTickerList.Count > 0)
{
TickerEntity[] tickerArray = dayTickerList.OrderBy(o => o.P).ToArray();
for (int i = 0; i < tickerArray.Length; i++)
{
if (i == 0)
{
weeklyTicker = tickerArray[i];
}
else
{
if (weeklyTicker.H < tickerArray[i].H)
{
weeklyTicker.H = tickerArray[i].H;
}
if (weeklyTicker.L > tickerArray[i].L)
{
weeklyTicker.L = tickerArray[i].L;
}
if (i == tickerArray.Length - 1)
{
weeklyTicker.C = tickerArray[i].C;
weeklyTicker.P = period;
}
weeklyTicker.V += tickerArray[i].V;
}
}
}
return(weeklyTicker);
}
// GetTicker
public async Task <Ticker> GetTicker(string currency, TradingPair tradingPair)
{
string market = String.Format("{0}_{1}", currency, tradingPair.ToString());
using (var client = new HttpClient())
{
SetHttpClientProperties(client);
// create the URL string.
var url = string.Format("api/public/getticker?market={0}", market);
// make the request
var response = await client.GetAsync(url);
// parse the response and return the data.
var jsonResponseString = await response.Content.ReadAsStringAsync();
TickerEntity tickerEntity = new TickerEntity();
try
{
tickerEntity = JsonConvert.DeserializeObject <TickerEntity>(jsonResponseString);
}
catch (Exception e)
{
throw new Exception(_ParseError, e);
}
// Check success message from server
if (tickerEntity.Success == false)
{
throw new Exception(_SuccessError);
}
return(tickerEntity.Result);
}
}
public Coin(ulong c, TickerEntity t)
{
Count = c;
Ticker = t;
Time = new MyDateTime();
}
