private static StockTickerData CreateEmptyStockData(DateTime dateTime)
        {
            var data = new StockTickerData();

            data.Date = dateTime;
            //data.Close = double.NaN;
            //data.Volume = double.NaN;
            return(data);
        }
 public void UpdateLastStockData(StockTickerData stockData)
 {
     if (Data.Any() && FilteredData.Any())
     {
         var lastStockData = this.Data.Last();
         if (lastStockData.Date.DayOfYear == stockData.Date.DayOfYear)
         {
             this.Data[this.Data.Count - 1] = stockData;
             this.FilteredData[this.FilteredData.Count - 1] = stockData;
         }
         else
         {
             this.Data.Add(stockData);
             this.FilteredData.Add(stockData);
         }
     }
 }
Exemple #3
0
        private void OnRequestStockHistoryCompleted(object sender, OpenReadCompletedEventArgs response)
        {
            var stockToken = new StockToken();

            if (response.UserState != null)
            {
                stockToken = (StockToken)response.UserState;
            }

            var process = "StockQuandlService -> Requesting stock history for " + stockToken.Symbol;

            if (response.Cancelled || response.Error != null)
            {
                Debug.WriteLine(process + " failed: \n   at " + response.Error);
                //ReportServerError(e.Error);
                return;
            }

            Debug.WriteLine(process + " completed");


            var csv          = DataProvider.GetCsvFile(response.Result);
            var culture      = CultureInfo.InvariantCulture;
            var stockHistory = new StockTickerList();

            #region Parse csv data and create stock history
            //      0,    1,    2,   3,     4,      5,        6,           7,
            //   Date, Open, High, Low, Close, Volume, Dividend, Split Ratio, Adj. Open,Adj. High,Adj. Low,Adj. Close,Adj. Volume
            // 2015-09-10,247.23,250.7231,245.33,248.381,2700138.0,0.0,1.0,247.23,250.7231,245.33,248.381,2700138.0
            // 2015-09-09,252.05,254.25,248.303,248.91,3363641.0,0.0,1.0,252.05,254.25,248.303,248.91,3363641.0

            for (var i = 1; i < csv.Count; i++)
            {
                var line  = csv[i];
                var stock = new StockTickerData();
                stock.Date = DateTime.ParseExact(line[0], StockDateFormat, culture);

                stock.Open   = double.Parse(line[1]);
                stock.High   = double.Parse(line[2]);
                stock.Low    = double.Parse(line[3]);
                stock.Close  = double.Parse(line[4]);
                stock.Volume = double.Parse(line[5]);

                //stock.Dividend = double.Parse(line[6]);
                //stock.Split = double.Parse(line[7]);

                stockHistory.Add(stock);

                var day = stock.Date.ToString();
                if (!TradingDates.ContainsKey(day))
                {
                    TradingDates.Add(day, stock.Date);
                }
            }
            #endregion

            stockHistory.Sort((x, y) => + (Comparer <DateTime> .Default.Compare(x.Date, y.Date)));

            // stockHistory.Sort((x, y) => Comparer.Ascending(x.Date, y.Date));

            Debug.WriteLine(process + " data parsed: " + stockHistory.Count);

            if (stockHistory.Count > 0)
            {
                var first = stockHistory.First();
                var count = stockHistory.Count;
                while (first.Date > stockToken.StartDate)
                {
                    var newStock = new StockTickerData {
                        Date = first.Date.AddDays(-1)
                    };
                    if (TradingDates.ContainsKey(newStock.Date.ToString()))
                    {
                        stockHistory.Insert(0, newStock);
                    }

                    first = newStock;
                }
                var delta = stockHistory.Count - count;
                if (delta > 0)
                {
                    Debug.WriteLine("StockQuandlService -> Aligned stock data by adding " + delta + " items");
                }
            }
            Debug.WriteLine(process + " data aligned: " + stockHistory.Count);

            _cache.UpdateCache(stockToken.Symbol, new List <object> {
                stockHistory
            });


            SynchronizationContext.Current.Post(data =>
                                                stockToken.Callback(stockToken.Symbol, (StockTickerList)data), stockHistory);
        }
        /// <summary>
        /// Called when [refresh data].
        /// </summary>
        /// <param name="symbol">The symbol.</param>
        /// <param name="data">The data.</param>
        private void OnRefreshData(string symbol, List <StockPriceItem> data)
        {
            Logs.Message(this, "OnRefreshData for " + symbol + " stock: " + data.Count);
            var sivm = GetStockInfoBySymbolName(symbol);

            if (sivm == null)
            {
                return;
            }
            var yearAgo    = DateTime.Now.AddYears(-1);
            var low        = double.MaxValue;
            var high       = double.MinValue;
            var collection = new ObservableCollection <StockTickerData>();

            foreach (var item in data)
            {
                var stock = new StockTickerData();
                stock.Open   = item.Open;
                stock.High   = item.High;
                stock.Low    = item.Low;
                stock.Close  = item.Close;
                stock.Volume = item.Volume;
                stock.Date   = item.Date;

                collection.Add(stock);
                // find low/high range for last year
                if (item.Date > yearAgo)
                {
                    low  = Math.Min(low, item.Low);
                    high = Math.Max(high, item.High);
                }
            }
            sivm.Data = collection;

            SetStockDisplayRange(_stockDisplayRange);

            var name       = symbol;
            var stockMatch = FindStockMatching(symbol);

            if (stockMatch != null)
            {
                name = stockMatch.Name;
                if (name.EndsWith("Corp."))
                {
                    name = name.Replace("Corp.", "Corporation");
                }
                if (name.EndsWith("Inc"))
                {
                    name = name.Replace("Inc", "Inc.");
                }
                if (name.EndsWith("Ltd"))
                {
                    name = name.Replace("Ltd", "Ltd.");
                }
            }

            if (sivm.Data.Any())
            {
                var lastDataPoint = sivm.Data.Last();
                DebugManager.LogData("StockViewModel.OnRefreshData initializing stock details : " + symbol);

                sivm.Details = new StockTickerDetails
                {
                    Symbol          = symbol,
                    Name            = name,
                    DailyHigh       = lastDataPoint.High,
                    DailyLow        = lastDataPoint.Low,
                    Open            = lastDataPoint.Open,
                    Volume          = lastDataPoint.Volume,
                    PreviousClose   = lastDataPoint.Close,
                    LastUpdate      = lastDataPoint.Date,
                    LastTradeAmount = lastDataPoint.Open,
                    LastTradeDate   = lastDataPoint.Date.ToString(CultureInfo.InvariantCulture),
                    LastTradeTime   = lastDataPoint.Date.TimeOfDay.ToString(),
                    YearlyLow       = low,
                    YearlyHigh      = high,
                };
            }

            UpdateStocksLayout();

            OnPropertyChanged("SelectedStock");
            OnPropertyChanged("Tickers");
            //OnPropertyChanged("IsDetailsPopulated");

            StockSimulationTimer.Start();
            StockServiceTimer.Start();

            this.OnInitialDataLoaded();
            //TODO-MT wait for all stocks to load
            this.IsInitialStockDataLoading = false;
        }