public StockDataItem(StockDataItem stock)
 {
     Symbol   = stock.Symbol;
     Split    = stock.Split;
     Dividend = stock.Dividend;
     Volume   = stock.Volume;
     Close    = stock.Close;
     Open     = stock.Open;
     High     = stock.High;
     Low      = stock.Low;
 }
        //private StockTickerData TickerSellData;
        //private StockTickerData TickerBuyData;

        //private ObservableCollection<StockTickerData> TickerSellDataList = new ObservableCollection<StockTickerData>();
        //private ObservableCollection<StockTickerData> TickerBuyDataList = new ObservableCollection<StockTickerData>();

        //   public void UpdateStockPrices()
        //{
        //       var twoSecIndex = DateTime.Now.Second % 2;
        //       //we're in the same 2-sec interval, just update values
        //       if (oldTwoSecIndex == twoSecIndex)
        //       {
        //           TickerSellData.Close = this.Bid;
        //           if (TickerSellData.High < this.Bid)
        //               TickerSellData.High = this.Bid;
        //           if (TickerSellData.Low > this.Bid)
        //               TickerSellData.Low = this.Bid;

        //           TickerBuyData.Close = this.Ask;
        //           if (TickerBuyData.High < this.Ask)
        //               TickerBuyData.High = this.Ask;
        //           if (TickerBuyData.Low > this.Ask)
        //               TickerBuyData.Low = this.Ask;
        //       }
        //       //change of interval, add current data to buffers, initialize new ticker data
        //       else
        //       {
        //           //oldTwoSec is -1 the first time a position is updated, so insert the ticker data if it's different from -1
        //           if (oldTwoSecIndex != -1)
        //           {
        //               TickerBuyDataList.Add(TickerBuyData);
        //               TickerSellDataList.Add(TickerSellData);

        //               //keep track of the last minute of real-time data
        //               //30 2-sec intervals = one minutes worth of data
        //               //remove the oldest data point once data for more than a minute is accumulated
        //               if (TickerBuyDataList.Count == 31)
        //                   TickerBuyDataList.RemoveAt(0);
        //               if (TickerSellDataList.Count == 31)
        //                   TickerSellDataList.RemoveAt(0);
        //           }

        //           oldTwoSecIndex = twoSecIndex;
        //           TickerSellData = new StockTickerData();
        //           TickerSellData.Date = DateTime.Now;
        //           TickerSellData.Open = this.Bid;
        //           TickerSellData.Close = this.Bid;
        //           TickerSellData.High = this.Bid;
        //           TickerSellData.Low = this.Bid;

        //           TickerBuyData = new StockTickerData();
        //           TickerBuyData.Date = DateTime.Now;
        //           TickerBuyData.Open = this.Ask;
        //           TickerBuyData.Close = this.Ask;
        //           TickerBuyData.High = this.Ask;
        //           TickerBuyData.Low = this.Ask;
        //       }
        //   }

        public StockDataItem ToStockData()
        {
            var stockData = new StockDataItem();

            stockData.Close  = LastTradeAmount;
            stockData.Open   = Open;
            stockData.High   = DailyHigh;
            stockData.Low    = DailyLow;
            stockData.Volume = Volume;
            stockData.Date   = LastUpdate;
            return(stockData);
        }
        public List <StockDataItem> ReadStockHistory(WebServiceResponse response)
        {
            var symbol     = "????";
            var stockToken = response.UserState as StockDataToken;

            if (stockToken != null)
            {
                symbol = stockToken.Symbol;
            }

            var process = "Reading stock history for " + symbol;

            var stockHistory = new List <StockDataItem>();

            if (response.ErrorOccured)
            {
                Logs.Error(this, process + " failed: \n\t at " + response.StatusInfo);

                var error = new Exception(response.ErrorStack);
                //OnRequestCompleted(stockHistory, symbol, error);
                return(stockHistory);
            }

            Logs.Message(this, process + " status: " + response.StatusInfo);

            var stream  = response.ResultStream;
            var csv     = DataProvider.GetCsvFile(stream);
            var culture = CultureInfo.InvariantCulture;

            #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 StockDataItem();
                stock.Date = DateTime.ParseExact(line[0], StockDateFormat, culture);
                stock.Date = SetTime(stock.Date, 16, 30, 00);

                stock.Symbol = symbol;
                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);
            }

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

            Logs.Message(this, "Data parsed: " + stockHistory.Count);

            #endregion

            #region Align data
            var alingnedDays = 0;
            Logs.Message(this, "Data aligned start: " + stockHistory.Count);
            if (stockHistory.Count > 0)
            {
                var first = stockHistory.First();
                while (first.Date > HistoryStartDate)
                {
                    var newStock = new StockDataItem();
                    newStock.Date   = first.Date.AddDays(-1);
                    newStock.Symbol = symbol;

                    if (newStock.Date.DayOfWeek != DayOfWeek.Saturday &&
                        newStock.Date.DayOfWeek != DayOfWeek.Sunday)
                    {
                        alingnedDays++;
                        stockHistory.Insert(0, newStock);
                    }

                    first = newStock;
                }

                var last        = stockHistory.Last();
                var latestStock = new StockDataItem(last);
                latestStock.Date = DateTime.Now;

                stockHistory.Add(latestStock);
            }
            Logs.Message(this, "Data aligned end: " + stockHistory.Count + " alingnedDays=" + alingnedDays);

            #endregion

            Cache.UpdateCache(symbol, stockHistory);

            return(stockHistory);
        }