private void UpdateAllButton_Click(object sender, RoutedEventArgs e)
 {
     new Thread(() =>
     {
         DatabaseController databaseController = new DatabaseController();
         databaseController.UpdateStockIndexesTable();
         stockIndexesList = databaseController.stockIndexes.OrderBy(b => b.symbol).ToList();
         Dispatcher.Invoke(() =>
         {
             UpdateMyStockDetailData();
             OnPropertyChanged("stockIndexesList");
             OnPropertyChanged("myStockIndexesList");
         });
     }).Start();
 }
        /// <summary>
        /// Metoda przygotowuje baze danych do pracy
        /// W razie potrzeby pobiera z serwera informacje o dostepnych indeksach
        /// oraz aktualizuje informacje historyczne dla pierwszego indeksu
        /// </summary>
        private void DatabaseSetup()
        {
            DatabaseController dbController = new DatabaseController();

            if (!dbController.stockIndexes.Any())
            {
                dbController.FillStockIndexesTable();
            }

            stockIndexesList = dbController.stockIndexes.OrderBy(b => b.symbol).ToList();
            if (!dbController.historicalIndexes.Where(x => x.symbol == stockIndexesList.First().symbol).Any())
            {
                dbController.FillHistoricalTable(stockIndexesList.First().symbol);
            }
            myStockIndexesList = dbController.myStocks.OrderBy(x => x.symbol).ToList();
        }
        /// <summary>
        /// Metoda odswieza widok w zakladce zakupionych indeksow
        /// </summary>
        private void UpdateSelectedMyStock()
        {
            DatabaseController databaseController = new DatabaseController();

            if (ListOfMyStocks.SelectedIndex != -1)
            {
                var item        = (MyStock)ListOfMyStocks.SelectedItem;
                var currentItem = databaseController.stockIndexes.Where(x => x.symbol == item.symbol).FirstOrDefault();
                CurrentPrice.Text = currentItem.price.ToString("0.00");
                MyPrice.Text      = item.indexPrice.ToString("0.00");
                MyProfit.Text     = item.profit.ToString("+0.00;-0.00;0");
                new Thread(() =>
                {
                    UpdateMyStockProfitGraph(item);
                }).Start();
            }
        }
        /// <summary>
        /// Metoda odswieza dane o historycznych zarobkach zakupionych indeksow
        /// </summary>
        /// <param name="myStock">transakcja dla ktorej odswiezyc dane</param>
        private void UpdateMyStockProfit(MyStock myStock)
        {
            DatabaseController databaseController = new DatabaseController();
            DateTime           newestProfit;

            if (databaseController.myStockProfits.Where(x => x.transactionID == myStock.transactionID).Any())
            {
                newestProfit = databaseController.myStockProfits
                               .Where(x => x.symbol == myStock.symbol)
                               .OrderByDescending(x => x.date)
                               .FirstOrDefault().date;
            }
            else
            {
                newestProfit = myStock.transactionDate;
            }

            bool NeedToUpdateHistorical = !databaseController.historicalIndexes
                                          .Where(x => x.symbol == myStock.symbol)
                                          .Where(x => x.date.Date == DateTime.Today.AddDays(-1))
                                          .Any();

            if (NeedToUpdateHistorical && myStock.transactionDate < DateTime.Today)
            {
                databaseController.FillHistoricalTable(myStock.symbol);
            }

            var list = databaseController.historicalIndexes
                       .Where(x => x.symbol == myStock.symbol)
                       .Where(x => x.date > newestProfit)
                       .OrderByDescending(x => x.date)
                       .ToList();

            foreach (var l in list)
            {
                databaseController.myStockProfits.Add(new MyStockProfit
                {
                    date          = l.date,
                    profit        = l.price - myStock.indexPrice,
                    transactionID = myStock.transactionID,
                    symbol        = myStock.symbol
                });
                databaseController.SaveChanges();
            }
        }
        /// <summary>
        /// Metoda odswieza oraz tworzy wykres zarobkow w czasie
        /// </summary>
        /// <param name="myStock">transkacja dla ktorej stworzyc wykres</param>
        private void UpdateMyStockProfitGraph(MyStock myStock)
        {
            DatabaseController databaseController = new DatabaseController();

            bool isMyStockProfitUpdated = databaseController.myStockProfits
                                          .Where(x => x.symbol == myStock.symbol)
                                          .Where(x => x.date.Date == DateTime.Today.Date.AddDays(-1))
                                          .Any();

            if (!isMyStockProfitUpdated)
            {
                UpdateMyStockProfit(myStock);
            }

            Dispatcher.Invoke(() =>
            {
                LineSeries stepLineSeries = new LineSeries();
                stepLineSeries.Values     = new ChartValues <MyStockProfit>();
                stepLineSeries.Values.AddRange(databaseController.myStockProfits.Where(x => x.transactionID == myStock.transactionID).OrderByDescending(x => x.date));
                ProfitChartSeries.Values = stepLineSeries.Values;
            });
        }
        private void UpdateButton_Click(object sender, RoutedEventArgs e)
        {
            UpdateButton.IsEnabled = false;
            var    item   = (StockIndex)ListOfRealStocks.SelectedItem;
            Thread thread = new Thread(() =>
            {
                if (item != null)
                {
                    DatabaseController databaseController = new DatabaseController();
                    databaseController.UpdateHistoricalTable(item.symbol);
                }
                Dispatcher.Invoke(() =>
                {
                    if (item == (StockIndex)ListOfRealStocks.SelectedItem)
                    {
                        UpdateHistoricalIndexGraph();
                    }
                    UpdateButton.IsEnabled = true;
                });
            });

            thread.Start();
        }
        /// <summary>
        /// Metoda odswieza wykres danych historycznych dla aktualnie wybranego indeksu
        /// </summary>
        private void UpdateHistoricalIndexGraph()
        {
            DatabaseController dbController = new DatabaseController();
            var item = (StockIndex)ListOfRealStocks.SelectedItem;

            if (item != null)
            {
                var historicalData = dbController.historicalIndexes.Where(x => x.symbol == item.symbol).Where(x => x.date > DateTime.Now.AddYears(-1)).OrderByDescending(x => x.date);
                if (historicalData.Any())
                {
                    CreateGraphData(historicalData);
                    ShowStockGraph();
                }
                else
                {
                    HideStockGraph();
                }
            }
            else
            {
                HideStockGraph();
            }
        }