public string Format(TickerSymbol symbol)
{
if (symbol == null) throw new ArgumentNullException("symbol");
var name = symbol.Symbol.ToUpper();
switch (symbol.Exchange)
{
case Exchange.Nasdaq:
return "NASDAQ:" + name;
case Exchange.Nyse:
return "NYSE:" + name;
case Exchange.Lse:
return "LON:" + name;
case Exchange.Asx:
return "ASX:" + name;
case Exchange.Nzx:
return "NZX:" + name;
default:
throw new UnsupportedExchangeException(
String.Format("Don't know how to get data for {0} exchange from Google Finance.", symbol.Exchange));
}
}
/// <derived/>
public ICollection <LoadedMarketData> Load(TickerSymbol ticker, IList <MarketDataType> dataNeeded,
DateTime from, DateTime to)
{
try
{
string fileCSV = "";
foreach (TickerSymbol tickerSymbol in fileList.Keys)
{
if (tickerSymbol.Symbol.ToLower().Equals(ticker.Symbol.ToLower()))
{
if (fileList.TryGetValue(tickerSymbol, out fileCSV))
{
return(File.Exists(fileCSV) ?
(ReadAndCallLoader(tickerSymbol, dataNeeded, from, to, fileCSV)) : null); //If file does not exist
}
return(null); //Problem reading list
}
}
return(null); //if ticker is not defined
}
catch (FileNotFoundException fnfe)
{
Console.WriteLine("Problem with loading data for instruments", fnfe);
return(null);
}
}
public ScraperResults GetFundamentals(TickerSymbol symbol)
{
if (symbol == null) throw new ArgumentNullException("symbol");
var formattedSymbol = Formatter.Format(symbol);
var url = new Uri(String.Format(XmlApiUrlFormat, formattedSymbol));
IDictionary<string, string> fundamentals;
try
{
fundamentals = GetFundamentals(symbol, url);
}
catch (Exception e)
{
throw new ScraperException(symbol, this, e);
}
if (!fundamentals.Any())
throw new NoFundamentalsAvailableException();
var friendlyUrl = new Uri(String.Format(FriendlyUrlFormat, formattedSymbol));
return new ScraperResults(friendlyUrl, fundamentals);
}
public void It_should_throw_a_no_fundamentals_available_exception()
{
var symbol = new TickerSymbol("asdfb", Exchange.Nyse);
var scraper = new FtDotComFinancials();
Assert.Throws<NoFundamentalsAvailableException>(() => scraper.GetFundamentals(symbol));
}
public string Format(TickerSymbol symbol)
{
if (symbol == null) throw new ArgumentNullException("symbol");
var name = symbol.Symbol.ToUpper();
switch (symbol.Exchange)
{
case Exchange.Nasdaq:
return name + ":NSQ";
case Exchange.Nyse:
return name + ":NYQ";
case Exchange.Lse:
return name + ":LSE";
case Exchange.Asx:
return name + ":ASX";
case Exchange.Nzx:
return name + ":NZC";
default:
throw new UnsupportedExchangeException(
String.Format("Don't know how to get data for {0} exchange from ft.com.", symbol.Exchange));
}
}
public string CreateWallet(WalletType Wallet, string ID, TickerSymbol Symbol = TickerSymbol.BTC)
{
if (walletDat.Exists(ID, Wallet, Symbol))
{
return(GetAddress(Wallet, ID, Symbol)); // if wallet already exists get current address
}
else
{
if (Wallet == WalletType.HotWallet)
{
return(string.Empty); // will add code later
}
else if (Wallet == WalletType.VaultWallet)
{
return(VaultWalletCreate(ID, Symbol));
}
else if (Wallet == WalletType.ExchangeWallet)
{
return(string.Empty); // will add code later
}
else
{
return(string.Empty);
}
}
}
public void DualTimeframeSignalAdvisor_GeneratesCloseSignal()
{
//Arrange
var forexPair = new TickerSymbol("EURUSD");
var m1Timeframe = new TimeframeUnit(TimeframeOption.M1);
var m5Timeframe = new TimeframeUnit(TimeframeOption.M5);
var feedService = new PriceFeedService(new ManualPriceFeeder(new MockFeedProvider()));
var signalTimeframe = feedService.Setup(forexPair, m1Timeframe, OHLCPriceOption.All);
var trendTimeframe = feedService.Setup(forexPair, m5Timeframe, OHLCPriceOption.All);
var signalAdvisor = new DualTimeframeSignalAdvisor(signalTimeframe, trendTimeframe);
signalAdvisor.Subscribe(feedService);
var position = PositionOption.None;
signalAdvisor.Buy += delegate(int strength) { position = PositionOption.Buy; };
signalAdvisor.Sell += delegate(int strength) { position = PositionOption.Sell; };
signalAdvisor.Close += delegate() { position = PositionOption.None; };
//Act
feedService.OHLC.PriceAction(signalTimeframe, new OHLCBar(DateTime.Now.Ticks, 11, 2, 3, 1));
feedService.OHLC.PriceAction(signalTimeframe, new OHLCBar(DateTime.Now.Ticks, 1, 2, 3, 1));
//Assert
Assert.AreEqual(position, PositionOption.None);
}
public string CreateAddress(WalletType Wallet, string ID, TickerSymbol Symbol = TickerSymbol.BTC)
{
if (walletDat.Exists(ID, Wallet))
{
return(GetAddress(Wallet, ID, Symbol));
}
else
{
//create wallets if there is no existing wallet
if (Wallet == WalletType.ExchangeWallet)
{
return(ExchangeWalletCreate(ID, Symbol));
}
else if (Wallet == WalletType.HotWallet)
{
return(HotWalletCreate(ID, Symbol));
}
else if (Wallet == WalletType.VaultWallet)
{
return(VaultWalletCreate(ID, Symbol));
}
else
{
return("NO WALLET CREATED"); // probably add error codes later
}
}
}
private WalletStore GetVaultWallet(string ID, TickerSymbol Symbol)
{
byte[] key = walletDat.LoadVault(ID);
return(new WalletStore {
Key = key
});
}
public static decimal GetMinerFee(TickerSymbol Symbol)
{
int satPerByte = 10;
int BytesEstimate = 300;
return(new Money(satPerByte * BytesEstimate).ToDecimal(MoneyUnit.BTC)); // implement later
}
/// <summary>
/// This method builds a URL to load data from Oanda for a neural
/// network to train with.
/// </summary>
/// <param name="ticker">The currency pair to access.</param>
/// <param name="from">The begin date.</param>
/// <param name="to">the ending date.</param>
/// <returns>The URL to read from.</returns>
private Uri buildURL(
TickerSymbol ticker,
DateTime from,
DateTime to
)
{
// construct the url
MemoryStream mstream = new MemoryStream();
FormUtility form = new FormUtility(mstream, null);
String[] currencies = ticker.Symbol.Split('/');
// each param gets added individually as query parameter
form.Add("exch", currencies[0].ToUpper());
form.Add("expr2", currencies[1].ToUpper());
form.Add("date1", from.ToString("MM-dd-yyyy"));
form.Add("date2", to.ToString("MM-dd-yyyy"));
form.Add("date_fmt", "us");
form.Add("lang", "en");
form.Add("margin_fixed", "0");
form.Add("SUBMIT", "Get+Table");
form.Add("format", "CSV");
form.Add("redirected", "1");
mstream.Close();
byte[] b = mstream.GetBuffer();
String str = "http://www.oanda.com/convert/fxhistory?"
+ StringUtil.FromBytes(b);
return(new Uri(str));
}
public void SingleTimeframeSignalAdvisor_ClosesSellPositionOnReversal()
{
//Arrange
var forexPair = new TickerSymbol("EURUSD");
var timeFrame = new TimeframeUnit(TimeframeOption.M1);
var feedService = new PriceFeedService(new ManualPriceFeeder(new MockFeedProvider()));
var signalTimeframe = feedService.Setup(forexPair, timeFrame, OHLCPriceOption.All);
var signalAdvisor = new SingleTimeframeSignalAdvisor(signalTimeframe);
signalAdvisor.Subscribe(feedService);
var position = PositionOption.None;
var closed = false;
signalAdvisor.Buy += delegate(int strength) { position = PositionOption.Buy; };
signalAdvisor.Sell += delegate(int strength) { position = PositionOption.Sell; };
signalAdvisor.Close += delegate()
{
position = PositionOption.None;
closed = true;
};
//Act
feedService.OHLC.PriceAction(signalTimeframe, new OHLCBar(DateTime.Now.Ticks, 11, 2, 3, 1));
feedService.OHLC.PriceAction(signalTimeframe, new OHLCBar(DateTime.Now.Ticks, 1, 2, 3, 11));
//Assert
Assert.AreEqual(position, PositionOption.Buy);
Assert.IsTrue(closed);
}
/// <summary>
/// Create a new Ticker Symbol for an added stock to the watchlist
/// </summary>
/// <param name="tickerSymbols"></param>
/// <param name="symbol"></param>
private TickerSymbol CreateNewTickerSymbol(List <TickerSymbol> tickerSymbols, string symbol)
{
var tickerSymbol = new TickerSymbol(context.User?.UserId, symbol);
tickerSymbols.Add(tickerSymbol);
return(tickerSymbol);
}
/// <summary>
/// Initializes a new instance of the DataPoint type using the specified time/data
/// </summary>
/// <param name="ticker">The ticker symbol associated with this data</param>
/// <param name="occured">The time this data was produced</param>
/// <param name="timezone">The timezone this data was produced in</param>
/// <param name="price">The data</param>
public IndicatorDataPoint(TickerSymbol ticker, DateTime occured, TimeZone timezone, decimal price)
{
Ticker = ticker;
Occured = occured;
Price = price;
TimeZone = timezone;
}
public void SingleTimeframeSignalAdvisor_GeneratesBuySignal()
{
//Arrange
var feeder = new ManualPriceFeeder(new MockFeedProvider());
var forexPair = new TickerSymbol("EURUSD");
var timeFrame = new TimeframeUnit(TimeframeOption.M1);
var feedService = new PriceFeedService(feeder);
var signalTimeframe = feedService.Setup(forexPair, timeFrame, OHLCPriceOption.All);
var signalAdvisor = new SingleTimeframeSignalAdvisor(signalTimeframe);
signalAdvisor.Subscribe(feedService);
feedService.Start();
var position = PositionOption.None;
signalAdvisor.Buy += delegate(int strength) { position = PositionOption.Buy; };
signalAdvisor.Sell += delegate(int strength) { position = PositionOption.Sell; };
signalAdvisor.Close += delegate() { position = PositionOption.None; };
//Act
feeder.MinutePriceAction(signalTimeframe, new PriceBar(DateTime.Now.Ticks, 1, 2, 3, 11));
//Assert
Assert.AreEqual(PositionOption.Buy, position);
Assert.AreEqual(signalAdvisor.Position, PositionOption.Buy);
Assert.AreEqual(100, signalAdvisor.PositionStrength);
}
private bool GetTickerSymbol(string pair, out TickerSymbol tickerSymbol, out CurrencyCode currencyCode)
{
bool okay1 = Enum.TryParse <TickerSymbol>(pair, true, out tickerSymbol);
bool okay2 = Enum.TryParse <CurrencyCode>(pair.Substring(3), true, out currencyCode);
return(okay1 && okay2);
}
public ScraperResults GetFundamentals(TickerSymbol symbol)
{
log.DebugFormat("Looking up symbol {0}", symbol);
var symbolFormat = Formatter.Format(symbol);
var region = Formatter.GetRegionOrDefault(symbol);
var strUrl = String.Format(ajaxUrlFormat, symbolFormat);
if (region != null)
strUrl = String.Format("{0}®ion={1}", strUrl, region);
var url = new Uri(strUrl);
log.DebugFormat("Using URL = {0}", strUrl);
IDictionary<string, string> fundamentals;
try
{
fundamentals = ScrapeFundamentals(url);
}
catch (Exception e)
{
throw new ScraperException(symbol, this, e);
}
if (!fundamentals.Any())
throw new NoFundamentalsAvailableException();
var friendlyUrl = new Uri(String.Format(ViewUrlFormat, symbolFormat));
return new ScraperResults(friendlyUrl, fundamentals);
}
public void It_should_throw_a_no_fundamentals_available_exception()
{
var symbol = new TickerSymbol("asdfb", Exchange.Nyse);
var scraper = new BloombergBusinessweekRatios();
Assert.Throws<NoFundamentalsAvailableException>(() => scraper.GetFundamentals(symbol));
}
/// <summary>
/// Load the market data.
/// </summary>
/// <returns> True if the data was loaded. </returns>
private bool LoadMarketData()
{
try
{
IMarketLoader loader = new YahooFinanceLoader();
var ticker = new TickerSymbol(Company.Text);
IList <MarketDataType> needed = new List <MarketDataType>();
needed.Add(MarketDataType.AdjustedClose);
needed.Add(MarketDataType.Close);
needed.Add(MarketDataType.Open);
needed.Add(MarketDataType.High);
needed.Add(MarketDataType.Low);
DateTime from = starting - TimeSpan.FromDays(365);
DateTime to = starting + TimeSpan.FromDays(365 * 2);
marketData = (List <LoadedMarketData>)loader.Load(ticker, needed, from, to);
marketData.Sort();
numberOfDays = (int)((ActualWidth - FirstDayOffset) / DayWidth);
numberOfDays = Math.Min(numberOfDays, marketData.Count);
return(true);
}
catch (Exception e)
{
MessageBox.Show("Ticker symbol likely invalid.\n" + e.Message, "Error Loading Data");
return(false);
}
}
public void It_should_throw_a_no_fundamentals_available_exception()
{
var symbol = new TickerSymbol("asdfb", Exchange.Nyse);
var scraper = new MorningstarCurrentValuation();
Assert.Throws<NoFundamentalsAvailableException>(() => scraper.GetFundamentals(symbol));
}
public ScraperResults GetFundamentals(TickerSymbol symbol)
{
Log.DebugFormat("Looking up symbol {0}", symbol);
var symbolFormat = Formatter.Format(symbol);
var url = new Uri(String.Format(AjaxUrlFormat, symbolFormat));
Log.DebugFormat("Using URL = {0}", url);
IDictionary<string, string> fundamentals;
try
{
fundamentals = ScrapeFundamentals(url);
}
catch (Exception e)
{
throw new ScraperException(symbol, this, e);
}
if (!fundamentals.Any())
throw new NoFundamentalsAvailableException();
var friendlyUrl = new Uri(String.Format(ViewUrlFormat, symbol.Symbol));
return new ScraperResults(friendlyUrl, fundamentals);
}
public Task<OrderBook> GetOrderBookAsync(TickerSymbol symbol)
{
if (!Enum.IsDefined(typeof(TickerSymbol), symbol))
throw new ArgumentException("symbol");
var request = new GetOrderBookMessageBuilder(symbol);
return SendAsync(request).ReadAsAsync<OrderBook, OrderBookMediaTypeFormatter>();
}
public Task<RecentTrades> GetRecentTradesAsync(TickerSymbol symbol, int? since = null)
{
if (!Enum.IsDefined(typeof(TickerSymbol), symbol))
throw new ArgumentException("symbol");
var request = new GetRecentTradesMessageBuilder(symbol, since);
return SendAsync(request).ReadAsAsync<RecentTrades>();
}
/// <summary>
/// True if this security can be subscribed to by this data feed
/// </summary>
/// <param name="ticker"></param>
/// <returns></returns>
public bool CanSubscribe(TickerSymbol ticker)
{
//Check for updates available tickers
UpdateTickers();
//Check for available ticker
return(_knowntickers.Contains(GetFeedTicker(ticker)));
}
/// <summary>
/// True if this security can be subscribed to by this data feed
/// </summary>
/// <param name="ticker"></param>
/// <returns></returns>
public bool CanSubscribe(TickerSymbol ticker)
{
//Check for updates in ticker symbols
UpdateTickers();
//Check if we know this symbol
return(_availableTickers.Contains(GetFeedTicker(ticker)));
}
public Task<Ticker> GetTickerAsync(TickerSymbol symbol)
{
if (!Enum.IsDefined(typeof(TickerSymbol), symbol))
throw new ArgumentException("symbol");
var request = new GetTickerMessageBuilder(symbol);
return SendAsync(request).ReadAsAsync<Ticker>();
}
/// <summary>
/// True if this security can be subscribed to by this data feed
/// </summary>
/// <param name="ticker"></param>
/// <returns></returns>
public bool CanSubscribe(TickerSymbol ticker)
{
//Get updates to ticker symbols
UpdateTickers();
//Return check
return(_availableTickers.Contains(GetFeedTicker(ticker)));
}
/// <summary>
/// Gets the fire hose subscription.
/// </summary>
/// <param name="datasource">The data source.</param>
/// <returns></returns>
public static DataSubscriptionRequest GetFireHoseSubscriptionRequest(DataSource datasource) =>
new DataSubscriptionRequest
{
Aggregation = null,
DataSource = datasource,
DataType = DataType.Tick,
Ticker = TickerSymbol.All()
};
/// <summary>
/// Create a new tick
/// </summary>
/// <param name="ticker"></param>
/// <param name="datasource"></param>
public Tick(TickerSymbol ticker, DataSource datasource)
{
Ticker = ticker;
DataType = DataType.Tick;
BidSource = datasource;
AskSource = datasource;
Source = datasource;
}
/// <summary>
/// Initializes a new instance of the <see cref="Delisting"/> class.
/// </summary>
/// <param name="state"></param>
/// <param name="ticker"></param>
/// <param name="processed"></param>
public Delisting(TickerSymbol ticker, string state, DateTime processed)
: this()
{
Ticker = ticker;
State = state;
Occured = processed;
TimeZone = TimeZone.Utc;
}
public ICollection<LoadedMarketData> ReadAndCallLoader(TickerSymbol symbol, IList<MarketDataType> neededTypes, DateTime from, DateTime to, string File)
{
try
{
//We got a file, lets load it.
ICollection<LoadedMarketData> result = new List<LoadedMarketData>();
ReadCSV csv = new ReadCSV(File, true, CSVFormat.English);
csv.DateFormat = "yyyy.MM.dd HH:mm:ss";
DateTime ParsedDate = from;
// Time,Open,High,Low,Close,Volume
while (csv.Next() && ParsedDate >= from && ParsedDate <= to )
{
DateTime date = csv.GetDate("Time");
double Bid= csv.GetDouble("Bid");
double Ask = csv.GetDouble("Ask");
double AskVolume = csv.GetDouble("AskVolume");
double BidVolume= csv.GetDouble("BidVolume");
double _trade = ( Bid + Ask ) /2;
double _tradeSize = (AskVolume + BidVolume) / 2;
LoadedMarketData data = new LoadedMarketData(date, symbol);
data.SetData(MarketDataType.Trade, _trade);
data.SetData(MarketDataType.Volume, _tradeSize);
result.Add(data);
Console.WriteLine("Current DateTime:"+ParsedDate.ToShortDateString()+ " Time:"+ParsedDate.ToShortTimeString() +" Start date was "+from.ToShortDateString());
Console.WriteLine("Stopping at date:" + to.ToShortDateString() );
ParsedDate = date;
//double open = csv.GetDouble("Open");
//double close = csv.GetDouble("High");
//double high = csv.GetDouble("Low");
//double low = csv.GetDouble("Close");
//double volume = csv.GetDouble("Volume");
//LoadedMarketData data = new LoadedMarketData(date, symbol);
//data.SetData(MarketDataType.Open, open);
//data.SetData(MarketDataType.High, high);
//data.SetData(MarketDataType.Low, low);
//data.SetData(MarketDataType.Close, close);
//data.SetData(MarketDataType.Volume, volume);
result.Add(data);
}
csv.Close();
return result;
}
catch (Exception ex)
{
Console.WriteLine("Something went wrong reading the csv");
Console.WriteLine("Something went wrong reading the csv:" + ex.Message);
}
Console.WriteLine("Something went wrong reading the csv");
return null;
}
/// <summary>
/// Reads the CSV and call loader.
/// Used internally to load the csv and place data in the marketdataset.
/// </summary>
/// <param name="symbol">The symbol.</param>
/// <param name="neededTypes">The needed types.</param>
/// <param name="from">From.</param>
/// <param name="to">To.</param>
/// <param name="File">The file.</param>
/// <returns></returns>
ICollection<LoadedMarketData> ReadAndCallLoader(TickerSymbol symbol, IEnumerable<MarketDataType> neededTypes, DateTime from, DateTime to, string File)
{
//We got a file, lets load it.
ICollection<LoadedMarketData> result = new List<LoadedMarketData>();
ReadCSV csv = new ReadCSV(File, true, CSVFormat.English);
//In case we want to use a different date format...and have used the SetDateFormat method, our DateFormat must then not be null..
//We will use the ?? operator to check for nullables.
csv.DateFormat = DateFormat ?? "yyyy-MM-dd HH:mm:ss";
csv.TimeFormat = "HH:mm:ss";
DateTime ParsedDate = from;
bool writeonce = true;
while (csv.Next())
{
DateTime date = csv.GetDate(0);
ParsedDate = date;
if (writeonce)
{
Console.WriteLine(@"First parsed date in csv:" + ParsedDate.ToShortDateString());
Console.WriteLine(@"Stopping at date:" + to.ToShortDateString());
Console.WriteLine(@"Current DateTime:" + ParsedDate.ToShortDateString() + @" Time:" +
ParsedDate.ToShortTimeString() + @" Asked Start date was " +
from.ToShortDateString());
writeonce = false;
}
if (ParsedDate >= from && ParsedDate <= to)
{
DateTime datex = csv.GetDate(0);
double open = csv.GetDouble(1);
double close = csv.GetDouble(2);
double high = csv.GetDouble(3);
double low = csv.GetDouble(4);
double volume = csv.GetDouble(5);
double range = Math.Abs(open - close);
double HighLowRange = Math.Abs(high - low);
double DirectionalRange = close - open;
LoadedMarketData data = new LoadedMarketData(datex, symbol);
data.SetData(MarketDataType.Open, open);
data.SetData(MarketDataType.High, high);
data.SetData(MarketDataType.Low, low);
data.SetData(MarketDataType.Close, close);
data.SetData(MarketDataType.Volume, volume);
data.SetData(MarketDataType.RangeHighLow, Math.Round(HighLowRange, 6));
data.SetData(MarketDataType.RangeOpenClose, Math.Round(range, 6));
data.SetData(MarketDataType.RangeOpenCloseNonAbsolute, Math.Round(DirectionalRange, 6));
result.Add(data);
}
}
csv.Close();
return result;
}
/// <summary>
/// Called to load training data for a company. This is how the training data is actually created.
/// To prepare input data for recognition use the CreateData method. The training set will be
/// added to. This allows the network to learn from multiple companies if this method is called
/// multiple times.
/// </summary>
/// <param name="symbol">The ticker symbol.</param>
/// <param name="training">The training set to add to.</param>
/// <param name="from">Beginning date</param>
/// <param name="to">Ending date</param>
public void LoadCompany(String symbol, BasicMLDataSet training, DateTime from, DateTime to)
{
IMarketLoader loader = new YahooFinanceLoader();
var ticker = new TickerSymbol(symbol);
IList <MarketDataType> dataNeeded = new List <MarketDataType>();
dataNeeded.Add(MarketDataType.AdjustedClose);
dataNeeded.Add(MarketDataType.Close);
dataNeeded.Add(MarketDataType.Open);
dataNeeded.Add(MarketDataType.High);
dataNeeded.Add(MarketDataType.Low);
var results = (List <LoadedMarketData>)loader.Load(ticker, dataNeeded, from, to);
results.Sort();
for (var index = PredictWindow; index < results.Count - EvalWindow; index++)
{
var data = results[index];
// determine bull or bear position, or neither
var bullish = false;
var bearish = false;
for (int search = 1; search <= EvalWindow; search++)
{
var data2 = results[index + search];
var priceBase = data.GetData(MarketDataType.AdjustedClose);
var priceCompare = data2.GetData(MarketDataType.AdjustedClose);
var diff = priceCompare - priceBase;
var percent = diff / priceBase;
if (percent > BullPercent)
{
bullish = true;
}
else if (percent < BearPercent)
{
bearish = true;
}
}
IMLDataPair pair = null;
if (bullish)
{
pair = CreateData(results, index, true);
}
else if (bearish)
{
pair = CreateData(results, index, false);
}
if (pair != null)
{
training.Add(pair);
}
}
}
public ICollection <LoadedMarketData> ReadAndCallLoader(TickerSymbol symbol, IList <MarketDataType> neededTypes, DateTime from, DateTime to, string File)
{
try
{
//We got a file, lets load it.
ICollection <LoadedMarketData> result = new List <LoadedMarketData>();
ReadCSV csv = new ReadCSV(File, true, CSVFormat.English);
csv.DateFormat = "yyyy.MM.dd HH:mm:ss";
DateTime ParsedDate = from;
// Time,Open,High,Low,Close,Volume
while (csv.Next() && ParsedDate >= from && ParsedDate <= to)
{
DateTime date = csv.GetDate("Time");
double Bid = csv.GetDouble("Bid");
double Ask = csv.GetDouble("Ask");
double AskVolume = csv.GetDouble("AskVolume");
double BidVolume = csv.GetDouble("BidVolume");
double _trade = (Bid + Ask) / 2;
double _tradeSize = (AskVolume + BidVolume) / 2;
LoadedMarketData data = new LoadedMarketData(date, symbol);
data.SetData(MarketDataType.Trade, _trade);
data.SetData(MarketDataType.Volume, _tradeSize);
result.Add(data);
Console.WriteLine("Current DateTime:" + ParsedDate.ToShortDateString() + " Time:" + ParsedDate.ToShortTimeString() + " Start date was " + from.ToShortDateString());
Console.WriteLine("Stopping at date:" + to.ToShortDateString());
ParsedDate = date;
//double open = csv.GetDouble("Open");
//double close = csv.GetDouble("High");
//double high = csv.GetDouble("Low");
//double low = csv.GetDouble("Close");
//double volume = csv.GetDouble("Volume");
//LoadedMarketData data = new LoadedMarketData(date, symbol);
//data.SetData(MarketDataType.Open, open);
//data.SetData(MarketDataType.High, high);
//data.SetData(MarketDataType.Low, low);
//data.SetData(MarketDataType.Close, close);
//data.SetData(MarketDataType.Volume, volume);
result.Add(data);
}
csv.Close();
return(result);
}
catch (Exception ex)
{
Console.WriteLine("Something went wrong reading the csv");
Console.WriteLine("Something went wrong reading the csv:" + ex.Message);
}
Console.WriteLine("Something went wrong reading the csv");
return(null);
}
/// <summary>
/// Creates a new subscription object.
/// </summary>
/// <param name="ticker">The ticker.</param>
/// <param name="datasource">The datasource.</param>
/// <param name="aggregation">The aggregation.</param>
/// <param name="datatype">The datatype.</param>
/// <returns></returns>
public static DataSubscriptionRequest CreateSubscriptionRequest(TickerSymbol ticker, DataSource datasource, TimeSpan?aggregation,
DataType datatype) =>
new DataSubscriptionRequest
{
Aggregation = aggregation,
DataSource = datasource,
DataType = datatype,
Ticker = ticker
};
/// <summary>
/// Reads the CSV and call loader.
/// Used internally to load the csv and place data in the marketdataset.
/// </summary>
/// <param name="symbol">The symbol.</param>
/// <param name="neededTypes">The needed types.</param>
/// <param name="from">From.</param>
/// <param name="to">To.</param>
/// <param name="File">The file.</param>
/// <returns></returns>
ICollection <LoadedMarketData> ReadAndCallLoader(TickerSymbol symbol, IEnumerable <MarketDataType> neededTypes, DateTime from, DateTime to, string File)
{
//We got a file, lets load it.
ICollection <LoadedMarketData> result = new List <LoadedMarketData>();
ReadCSV csv = new ReadCSV(File, true, CSVFormat.English);
//In case we want to use a different date format...and have used the SetDateFormat method, our DateFormat must then not be null..
//We will use the ?? operator to check for nullables.
csv.DateFormat = DateFormat ?? "yyyy-MM-dd HH:mm:ss";
csv.TimeFormat = "HH:mm:ss";
DateTime ParsedDate = from;
bool writeonce = true;
while (csv.Next())
{
DateTime date = csv.GetDate(0);
ParsedDate = date;
if (writeonce)
{
Console.WriteLine(@"First parsed date in csv:" + ParsedDate.ToShortDateString());
Console.WriteLine(@"Stopping at date:" + to.ToShortDateString());
Console.WriteLine(@"Current DateTime:" + ParsedDate.ToShortDateString() + @" Time:" +
ParsedDate.ToShortTimeString() + @" Asked Start date was " +
from.ToShortDateString());
writeonce = false;
}
if (ParsedDate >= from && ParsedDate <= to)
{
DateTime datex = csv.GetDate(0);
double open = csv.GetDouble(1);
double close = csv.GetDouble(2);
double high = csv.GetDouble(3);
double low = csv.GetDouble(4);
double volume = csv.GetDouble(5);
double range = Math.Abs(open - close);
double HighLowRange = Math.Abs(high - low);
double DirectionalRange = close - open;
LoadedMarketData data = new LoadedMarketData(datex, symbol);
data.SetData(MarketDataType.Open, open);
data.SetData(MarketDataType.High, high);
data.SetData(MarketDataType.Low, low);
data.SetData(MarketDataType.Close, close);
data.SetData(MarketDataType.Volume, volume);
data.SetData(MarketDataType.RangeHighLow, Math.Round(HighLowRange, 6));
data.SetData(MarketDataType.RangeOpenClose, Math.Round(range, 6));
data.SetData(MarketDataType.RangeOpenCloseNonAbsolute, Math.Round(DirectionalRange, 6));
result.Add(data);
}
}
csv.Close();
return(result);
}
/// <summary>
/// Initializes a new instance of the <see cref="QuoteBar"/> class.
/// </summary>
public QuoteBar()
{
Ticker = TickerSymbol.NIL("");
Occured = new DateTime();
Bid = new BarImpl();
Ask = new BarImpl();
Price = 0;
Period = TimeSpan.FromMinutes(1);
DataType = DataType.QuoteBar;
}
public ICollection<LoadedMarketData> Load(
TickerSymbol ticker,
IList<MarketDataType> dataNeeded,
DateTime from,
DateTime to)
{
// TODO: nyyyyyyyaaagh!
ICollection<LoadedMarketData> result =
new List<LoadedMarketData>();
Uri url = BuildURL(ticker, from, to);
WebRequest http = HttpWebRequest.Create(url);
HttpWebResponse response = http.GetResponse() as HttpWebResponse;
using (Stream istream = response.GetResponseStream())
{
ReadCSV csv = new ReadCSV(
istream,
true,
CSVFormat.DECIMAL_POINT
);
while (csv.Next())
{
// todo: edit headers to match
DateTime date = csv.GetDate("DATE");
date =
date.Add(
new TimeSpan(
csv.GetDate("TIME").Hour,
csv.GetDate("TIME").Minute,
csv.GetDate("TIME").Second
)
);
double open = csv.GetDouble("OPEN");
double high = csv.GetDouble("MIN");
double low = csv.GetDouble("MAX");
double close = csv.GetDouble("CLOSE");
double volume = csv.GetDouble("VOLUME");
LoadedMarketData data =
new LoadedMarketData(date, ticker);
data.SetData(MarketDataType.OPEN, open);
data.SetData(MarketDataType.HIGH, high);
data.SetData(MarketDataType.LOW, low);
data.SetData(MarketDataType.CLOSE, close);
data.SetData(MarketDataType.VOLUME, volume);
result.Add(data);
}
csv.Close();
istream.Close();
}
return result;
}
public ICollection <LoadedMarketData> Load(
TickerSymbol ticker,
IList <MarketDataType> dataNeeded,
DateTime from,
DateTime to)
{
// TODO: nyyyyyyyaaagh!
ICollection <LoadedMarketData> result =
new List <LoadedMarketData>();
Uri url = BuildURL(ticker, from, to);
WebRequest http = HttpWebRequest.Create(url);
HttpWebResponse response = http.GetResponse() as HttpWebResponse;
using (Stream istream = response.GetResponseStream())
{
ReadCSV csv = new ReadCSV(
istream,
true,
CSVFormat.DECIMAL_POINT
);
while (csv.Next())
{
// todo: edit headers to match
DateTime date = csv.GetDate("DATE");
date =
date.Add(
new TimeSpan(
csv.GetDate("TIME").Hour,
csv.GetDate("TIME").Minute,
csv.GetDate("TIME").Second
)
);
double open = csv.GetDouble("OPEN");
double high = csv.GetDouble("MIN");
double low = csv.GetDouble("MAX");
double close = csv.GetDouble("CLOSE");
double volume = csv.GetDouble("VOLUME");
LoadedMarketData data =
new LoadedMarketData(date, ticker);
data.SetData(MarketDataType.OPEN, open);
data.SetData(MarketDataType.HIGH, high);
data.SetData(MarketDataType.LOW, low);
data.SetData(MarketDataType.CLOSE, close);
data.SetData(MarketDataType.VOLUME, volume);
result.Add(data);
}
csv.Close();
istream.Close();
}
return(result);
}
public GetOrdersMessageBuilder(Guid walletId, Page page=null, TickerSymbol? instrument=null, OrderStatus? status=null)
{
_walletId = walletId;
_page = page;
_instrument = instrument.HasValue
? Enum.GetName(typeof(TickerSymbol), instrument)
: null;
_status = status.HasValue
? Enum.GetName(typeof(OrderStatus), status)
: null;
}
private string VaultWalletCreate(string ID, TickerSymbol Symbol, string[] Attributes = null)
{
Key nKey = new Key(); //generate new key
BitcoinSecret bitSecret = new BitcoinSecret(nKey, net); // create secret
BitcoinAddress bitAddress = bitSecret.PubKey.GetAddress(net); // create address from secret
walletDat.SaveVault(ID, nKey.ToBytes(), Attributes); // saves Data
return(bitAddress.ToString()); // returns recieveing address.
}
public void TestEquals()
{
var t0 = new TickerSymbol {
InstrumentType = "Common Stock", Symbol = "NFLX:US", Country = "USA"
};
var t1 = new TickerSymbol {
InstrumentType = "Common Stock", Symbol = "NFLX:US", Country = "USA"
};
Assert.IsTrue(t0.Equals(t1));
}
public Task <RecentTrades> GetRecentTradesAsync(TickerSymbol symbol, int?since = null)
{
if (!Enum.IsDefined(typeof(TickerSymbol), symbol))
{
throw new ArgumentException("symbol");
}
var request = new GetRecentTradesMessageBuilder(symbol, since);
return(SendAsync(request).ReadAsAsync <RecentTrades>());
}
public Task <OrderBook> GetOrderBookAsync(TickerSymbol symbol)
{
if (!Enum.IsDefined(typeof(TickerSymbol), symbol))
{
throw new ArgumentException("symbol");
}
var request = new GetOrderBookMessageBuilder(symbol);
return(SendAsync(request).ReadAsAsync <OrderBook, OrderBookMediaTypeFormatter>());
}
public Task <Ticker> GetTickerAsync(TickerSymbol symbol)
{
if (!Enum.IsDefined(typeof(TickerSymbol), symbol))
{
throw new ArgumentException("symbol");
}
var request = new GetTickerMessageBuilder(symbol);
return(SendAsync(request).ReadAsAsync <Ticker>());
}
public static NewOrder Buy(TickerSymbol instrument, CurrencyCode currency, decimal amount, decimal price)
{
return new NewOrder {
Side = OrderSide.buy,
Instrument = instrument,
Type = OrderType.limit,
Currency = currency,
Price = price,
Amount = amount,
Display = amount
};
}
public ICollection<LoadedMarketData> Load(TickerSymbol ticker, IList<MarketDataType> dataNeeded, DateTime from, DateTime to)
{
ICollection<LoadedMarketData> result = new List<LoadedMarketData>();
if (File.Exists(LoadedFile))
{
result = ReadAndCallLoader(ticker, dataNeeded, from, to, LoadedFile);
return result;
}
return null;
}
private static Uri BuildUrl(TickerSymbol ticker, DateTime from,
DateTime to)
{
// construct the URL
string uri = string.Format(
CultureInfo.InvariantCulture,
"http://finance.google.com/finance/historical?q={0}&histperiod=daily&startdate={1:MMM d, yyyy}&enddate={2:MMM d, yyyy}&output=csv",
ticker.Symbol.ToUpper(),
from,
to);
return new Uri(uri);
}
public Task<Order[]> GetOrdersAsync(Guid walletId, Page page, TickerSymbol instrument, OrderStatus status)
{
if (walletId == Guid.Empty)
throw new ArgumentException("walletId");
if (page == null)
throw new ArgumentNullException("page");
if (!Enum.IsDefined(typeof(TickerSymbol), instrument))
throw new ArgumentException("instrument");
if (!Enum.IsDefined(typeof(OrderStatus), status))
throw new ArgumentException("status");
var request = new GetOrdersMessageBuilder(walletId, page, instrument, status);
return SendAsync(request).ReadAsAsync<Order[]>();
}
public AggregationResults(
TickerSymbol symbol,
IEnumerable<ProviderResults> providers,
DateTime timestamp,
string longName,
IEnumerable<FundamentalResult> derivedValues)
{
if (symbol == null) throw new ArgumentNullException("symbol");
Timestamp = timestamp;
DerivedValues = derivedValues;
LongName = longName ?? "";
Symbol = symbol;
Providers = providers;
}
public bool IsSupportedExchange(TickerSymbol symbol)
{
switch (symbol.Exchange)
{
case Exchange.Lse:
case Exchange.Nasdaq:
case Exchange.Asx:
case Exchange.Nyse:
case Exchange.Nzx:
return true;
}
return false;
}
public bool IsSupportedExchange(TickerSymbol symbol)
{
if (symbol == null) throw new ArgumentNullException("symbol");
switch (symbol.Exchange)
{
case Exchange.Lse:
case Exchange.Nasdaq:
case Exchange.Asx:
case Exchange.Nyse:
return true;
}
return false;
}
public bool IsSupportedExchange(TickerSymbol symbol)
{
switch (symbol.Exchange)
{
// Full list is here: http://www.google.com/googlefinance/disclaimer/
case Exchange.Lse:
case Exchange.Nasdaq:
case Exchange.Asx:
case Exchange.Nyse:
case Exchange.Nzx:
return true;
}
return false;
}
public string GetRegionOrDefault(TickerSymbol symbol)
{
if (symbol == null) throw new ArgumentNullException("symbol");
switch (symbol.Exchange)
{
case Exchange.Lse:
return "GBR";
case Exchange.Asx:
return "AUS";
default:
return null;
}
}
public ICollection<LoadedMarketData> ReadAndCallLoader(TickerSymbol symbol, IList<MarketDataType> neededTypes, DateTime from, DateTime to,string File)
{
try
{
//We got a file, lets load it.
ICollection<LoadedMarketData> result = new List<LoadedMarketData>();
ReadCSV csv = new ReadCSV(File, true,LoadedFormat);
csv.DateFormat = DateTimeFormat.Normalize();
// Time,Open,High,Low,Close,Volume
while (csv.Next())
{
DateTime date = csv.GetDate("Time");
double open = csv.GetDouble("Open");
double close = csv.GetDouble("High");
double high = csv.GetDouble("Low");
double low = csv.GetDouble("Close");
double volume = csv.GetDouble("Volume");
LoadedMarketData data = new LoadedMarketData(date, symbol);
data.SetData(MarketDataType.Open, open);
data.SetData(MarketDataType.High, high);
data.SetData(MarketDataType.Low, low);
data.SetData(MarketDataType.Close, close);
data.SetData(MarketDataType.Volume, volume);
result.Add(data);
}
csv.Close();
return result;
}
catch (Exception ex)
{
Console.WriteLine("Something went wrong reading the csv");
Console.WriteLine("Something went wrong reading the csv:"+ex.Message);
}
Console.WriteLine("Something went wrong reading the csv");
return null;
}
public AggregationResults Aggregate(TickerSymbol symbol)
{
if (symbol == null) throw new ArgumentNullException("symbol");
var key = symbol.ToString();
if (cache.Contains(key))
return (AggregationResults)cache.Get(key);
var results = source.Aggregate(symbol);
cache.Add(key, results,
new CacheItemPolicy
{
AbsoluteExpiration = DateTime.UtcNow.Add(expireAfter)
});
return results;
}
/// <summary>
/// Load financial data from a CSV file.
/// </summary>
/// <param name="ticker">The ticker being loaded, ignored for a CSV load.</param>
/// <param name="dataNeeded">The data needed.</param>
/// <param name="from">The starting date.</param>
/// <param name="to">The ending date.</param>
/// <returns></returns>
public ICollection<LoadedMarketData> Load(TickerSymbol ticker, IList<MarketDataType> dataNeeded, DateTime from,
DateTime to)
{
try
{
if (File.Exists(TheFile))
{
//We got a file, lets load it.
TheFile = TheFile;
ICollection<LoadedMarketData> result = new List<LoadedMarketData>();
var csv = new ReadCSV(TheFile, true, CSVFormat.English);
// Time,Open,High,Low,Close,Volume
while (csv.Next())
{
DateTime date = csv.GetDate("Time");
double open = csv.GetDouble("Open");
double close = csv.GetDouble("High");
double high = csv.GetDouble("Low");
double low = csv.GetDouble("Close");
double volume = csv.GetDouble("Volume");
var data = new LoadedMarketData(date, ticker);
data.SetData(MarketDataType.Open, open);
data.SetData(MarketDataType.Volume, close);
data.SetData(MarketDataType.High, high);
data.SetData(MarketDataType.Low, low);
data.SetData(MarketDataType.Volume, volume);
result.Add(data);
}
csv.Close();
return result;
}
}
catch (Exception ex)
{
throw new LoaderError(ex);
}
throw new LoaderError(@"Something went wrong reading the csv");
}
/// <summary>
/// Load the specified financial data.
/// </summary>
/// <param name="ticker">The ticker symbol to load.</param>
/// <param name="dataNeeded">The financial data needed.</param>
/// <param name="from">The beginning date to load data from.</param>
/// <param name="to">The ending date to load data to.</param>
/// <returns>A collection of LoadedMarketData objects that represent the data
/// loaded.</returns>
public ICollection<LoadedMarketData> Load(TickerSymbol ticker,
IList<MarketDataType> dataNeeded, DateTime from,
DateTime to)
{
ICollection<LoadedMarketData> result =
new List<LoadedMarketData>();
Uri url = BuildURL(ticker, from, to);
WebRequest http = WebRequest.Create(url);
var response = (HttpWebResponse) http.GetResponse();
using (Stream istream = response.GetResponseStream())
{
var csv = new ReadCSV(istream, true, CSVFormat.DecimalPoint);
while (csv.Next())
{
DateTime date = csv.GetDate("date");
double adjClose = csv.GetDouble("adj close");
double open = csv.GetDouble("open");
double close = csv.GetDouble("close");
double high = csv.GetDouble("high");
double low = csv.GetDouble("low");
double volume = csv.GetDouble("volume");
var data =
new LoadedMarketData(date, ticker);
data.SetData(MarketDataType.AdjustedClose, adjClose);
data.SetData(MarketDataType.Open, open);
data.SetData(MarketDataType.Close, close);
data.SetData(MarketDataType.High, high);
data.SetData(MarketDataType.Low, low);
data.SetData(MarketDataType.Open, open);
data.SetData(MarketDataType.Volume, volume);
result.Add(data);
}
csv.Close();
istream.Close();
}
return result;
}
public ActionResult Fundamentals(string symbol, string exchange,
[ModelBinder(typeof(TruthyBooleanModelBinder))] bool json = false)
{
var ts = new TickerSymbol(symbol, (Exchange) Enum.Parse(typeof (Exchange), exchange, true));
Log.InfoFormat("Looking up symbol {0}", ts);
var results = aggregator.Aggregate(ts);
if (Request.AcceptTypes.Contains("application/json") || json)
return new JsonNetResult
{
Data = results,
SerializerSettings =
{
ContractResolver = new CamelCasePropertyNamesContractResolver()
}
};
return View(results);
}
public ProviderResults GetFundamentals(TickerSymbol symbol)
{
if (symbol == null) throw new ArgumentNullException("symbol");
var sw = Stopwatch.StartNew();
try
{
Log.DebugFormat("Looking up {0} via {1}", symbol, scraper.GetType());
var results = scraper.GetFundamentals(symbol);
var fundamentals = results.Fundamentals.Select(p => new FundamentalResult
{
Name = p.Key,
Value = p.Value,
IsHighlighted = highlighter.IsHighlighted(p.Key)
}).ToList();
return new ProviderResults(scraper.ProviderName, results.Url, fundamentals);
}
catch (NoFundamentalsAvailableException e)
{
Log.ErrorFormat("Could not find any fundamentals from {0}.", scraper.GetType());
Log.Error(e);
return new ProviderResults(scraper.ProviderName);
}
catch (Exception e)
{
Log.ErrorFormat("Scraper {0} failed!", scraper.GetType());
Log.Error(e);
return new ProviderResults(scraper.ProviderName, e);
}
finally
{
sw.Stop();
Log.DebugFormat("{0} total duration: {1}", scraper.GetType(), sw.Elapsed);
}
}
