public async System.Threading.Tasks.Task <List <DataBar> > GetHistoricalDataAsync(SecurityType securityType, string ticker, BarSize barSize, DateTime?endDate = null)
{
var client = new AlphaVantageStocksClient(Constants.AlphaVantageApiKey);
var HistoricalBarCollection = new List <DataBar>();
StockTimeSeries timeSeries;
switch (barSize)
{
case BarSize.DAY:
timeSeries = await client.RequestDailyTimeSeriesAsync(ticker, TimeSeriesSize.Full, adjusted : false);
break;
case BarSize.WEEK:
timeSeries = await client.RequestWeeklyTimeSeriesAsync(ticker, adjusted : false);
break;
case BarSize.MONTH:
timeSeries = await client.RequestMonthlyTimeSeriesAsync(ticker, adjusted : false);
break;
default:
timeSeries = await client.RequestIntradayTimeSeriesAsync(ticker, (IntradayInterval)barSize, TimeSeriesSize.Full);
break;
}
((List <StockDataPoint>)timeSeries.DataPoints).ForEach(bar => HistoricalBarCollection.Add(new DataBar(bar)));
return(HistoricalBarCollection);
}
public async void PrintSample()
{
var test = new AlphaVantageStocksClient(APIKey.key);
var data = await test.RequestIntradayTimeSeriesAsync(Ticker, AlphaVantage.Net.Stocks.TimeSeries.IntradayInterval.OneMin, AlphaVantage.Net.Stocks.TimeSeries.TimeSeriesSize.Full);
using (StreamWriter f = new StreamWriter("SPY.txt"))
{
foreach (var d in data.DataPoints)
{
Console.WriteLine($"{Ticker} H:{d.HighestPrice} L:{d.LowestPrice} Diff:{d.HighestPrice - d.LowestPrice} Volume: {d.Volume}");
//f.WriteLine($"{Ticker} {d.Time} Open:{d.OpeningPrice} H:{d.HighestPrice} L:{d.LowestPrice} Diff:{d.HighestPrice - d.LowestPrice} Volume: {d.Volume}");
}
}
}
public async void SaveMinOpenSample()
{
var test = new AlphaVantageStocksClient(APIKey.key);
var data = await test.RequestIntradayTimeSeriesAsync(Ticker, AlphaVantage.Net.Stocks.TimeSeries.IntradayInterval.OneMin, AlphaVantage.Net.Stocks.TimeSeries.TimeSeriesSize.Full);
using (StreamWriter f = new StreamWriter(Path.Combine(Directory.GetCurrentDirectory(), "SPYopen.txt")))
{
foreach (var d in data.DataPoints)
{
//Console.WriteLine($"{Ticker} H:{d.HighestPrice} L:{d.LowestPrice} Diff:{d.HighestPrice - d.LowestPrice} Volume: {d.Volume}");
f.WriteLine($"{d.OpeningPrice}");
}
}
}
public async static Task <List <StockDataPoint> > GetIntraDayInfo(string symbol, int numDataPoints)
{
try
{
var avClient = new AlphaVantageStocksClient(API_KEY_ALPHA_VANTAGE);
var info = await avClient.RequestIntradayTimeSeriesAsync(symbol, IntradayInterval.OneMin);
return(info.DataPoints.Take(numDataPoints).ToList());
}
catch (Exception e)
{
throw;
}
}
public async Task RequestIntradayTimeSeriesAsync_Test()
{
var client = new AlphaVantageStocksClient(ApiKey);
var result =
await client.RequestIntradayTimeSeriesAsync(Symbol, IntradayInterval.OneMin, TimeSeriesSize.Compact);
Assert.NotNull(result);
Assert.Equal(TimeSeriesType.Intraday, result.Type);
Assert.Equal(Symbol, result.Symbol);
Assert.NotNull(result.DataPoints);
Assert.True(result.DataPoints.All(p =>
p.GetType() == typeof(StockDataPoint) &&
p.GetType() != typeof(StockAdjustedDataPoint)));
}
//don't use? save actual day object instead?
public async Task UpdateDayFiles() //move to Stock.cs eventually
{
StockObj = await APIObj.RequestIntradayTimeSeriesAsync(Ticker, AlphaVantage.Net.Stocks.TimeSeries.IntradayInterval.OneMin, AlphaVantage.Net.Stocks.TimeSeries.TimeSeriesSize.Full);
DateTime lastDate = DateTime.Now.Date;//StockObj.DataPoints.First().Time.Date;
foreach (var sdp in StockObj.DataPoints)
{
if (sdp.Time.Date != lastDate)
{
lastDate = sdp.Time.Date;
//if (JSONDay)
}
}
}
async Task GetIntraData()
{
IntraDataDict.Clear();
var client = new AlphaVantageStocksClient(APIKey);
StockTimeSeries timeSeries = await client.RequestIntradayTimeSeriesAsync("GE", IntradayInterval.FiveMin, TimeSeriesSize.Compact); // client.RequestDailyTimeSeriesAsync("GE", TimeSeriesSize.Compact, false);
foreach (var dataPoint in timeSeries.DataPoints)
{
if (DateTime.Now.Date == dataPoint.Time.Date)
{
decimal[] tempDecimal = new decimal[4];
tempDecimal[0] = dataPoint.HighestPrice;
tempDecimal[1] = dataPoint.LowestPrice;
tempDecimal[2] = dataPoint.OpeningPrice;
tempDecimal[3] = dataPoint.ClosingPrice;
IntraDataDict[dataPoint.Time] = tempDecimal;
}
}
}
private async Task InitAPIObj()
{
APIObj = new AlphaVantageStocksClient(APIKey.key);
StockObj = await APIObj.RequestIntradayTimeSeriesAsync(Ticker, AlphaVantage.Net.Stocks.TimeSeries.IntradayInterval.OneMin, AlphaVantage.Net.Stocks.TimeSeries.TimeSeriesSize.Full);
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//debugging, dump data to file
/*string dumpFile = $"SPYDUMP_5-30-2020_11-02am.txt";
* if (!File.Exists(dumpFile))
* {
* using (StreamWriter f = new StreamWriter(Path.Combine(Directory.GetCurrentDirectory(), dumpFile)))
* {
* foreach (var sdp in StockObj.DataPoints)
* {
* string temp = $"Time:{sdp.Time}\tOpen:{sdp.OpeningPrice}\tClose:{sdp.ClosingPrice}\tVolume:{sdp.Volume}";
* f.WriteLine(temp);
* }
* }
* }*/
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
}
public async Task <IReadOnlyCollection <Rate> > DownloadRates()
{
//_symbols.;
var timeSeries = await _client.RequestIntradayTimeSeriesAsync("AAPL", IntradayInterval.ThirtyMin, TimeSeriesSize.Compact);
//var dateTime
var dataPoint = timeSeries?.DataPoints?.FirstOrDefault();
if (dataPoint == null)
{
return(Array.Empty <Rate>());
}
var rate = new Rate("USD", "AAPL", dataPoint.ClosingPrice, dataPoint.Time)
{
};
return(new List <Rate>()
{
rate
});
}
public async Task <List <int> > GetVolumeSample() //Get the volume for the last 5 trading days by minute? And reverse it so it's in order from oldest to newest
{
Console.WriteLine($"GetVolumeSample: {DateTime.Now}");
var outList = new List <int>();
var APIObj = new AlphaVantageStocksClient(APIKey.key);
var data = await APIObj.RequestIntradayTimeSeriesAsync(Ticker, AlphaVantage.Net.Stocks.TimeSeries.IntradayInterval.OneMin, AlphaVantage.Net.Stocks.TimeSeries.TimeSeriesSize.Full);
Console.WriteLine($"After data retrieved: {DateTime.Now}");
//outList = data.DataPoints.Select(x => x.Volume);
foreach (var min in data.DataPoints)
{
outList.Add((int)min.Volume);
}
Console.WriteLine($"After converted to list: {DateTime.Now}");
outList.Reverse();
Console.WriteLine($"After reversed: {DateTime.Now}");
return(outList);
}
public override async Task <MarketPriceRes> Execute(MarketPriceReq request)
{
try
{
string apiKey = plcalc.Common.Properties.Settings.Default.AlphaVantageApiKey;; // enter your API key here
var client = new AlphaVantageStocksClient(apiKey);
StockTimeSeries timeSeries;
StockDataPoint data = null;
switch (request.ApiFunction)
{
case ApiFunction.TIME_SERIES_DAILY:
timeSeries =
await client.RequestDailyTimeSeriesAsync(request.Ticker, TimeSeriesSize.Compact, adjusted : false);
if (request.getPreviousClose)
{
var prevDate = DateTime.Now.DayOfWeek == DayOfWeek.Monday
? DateTime.Now.AddDays(-3).Date
: DateTime.Now.Date.AddDays(-1).Date;
data = timeSeries.DataPoints.OrderByDescending(a => a.Time)
.FirstOrDefault(a => a.Time.Date == prevDate);
}
else
{
data = timeSeries.DataPoints.OrderByDescending(a => a.Time).FirstOrDefault();
}
if (data == null)
{
return(null);
}
return(new MarketPriceRes
{
Ticker = request.Ticker,
Date = data.Time,
Price = data.ClosingPrice
});
case ApiFunction.TIME_SERIES_INTRADAY:
timeSeries =
await client.RequestIntradayTimeSeriesAsync(request.Ticker, IntradayInterval.OneMin, TimeSeriesSize.Compact);
data = timeSeries.DataPoints.OrderByDescending(a => a.Time).FirstOrDefault();
if (data == null)
{
return(null);
}
return(new MarketPriceRes
{
Ticker = request.Ticker,
Date = data.Time,
Price = data.ClosingPrice
});
default:
throw new plcalcException("Invalid apifunction");
}
}
catch (Exception ex)
{
//log error
return(null);
}
}