Example #1
0
        private void UploadButton_Click(object sender, RoutedEventArgs e)
        {
            // Create OpenFileDialog
            Microsoft.Win32.OpenFileDialog dlg = new Microsoft.Win32.OpenFileDialog();

            // Set filter for file extension and default file extension
            dlg.DefaultExt = ".csv";
            dlg.Filter     = "Excel Files (*.xls;*.xlsx;*.csv)|*.xls;*.xlsx;*.csv";

            // Display OpenFileDialog by calling ShowDialog method
            bool?result = dlg.ShowDialog();

            if (result == true)
            {
                // Open document
                string filename = dlg.FileName;
                if (Path.GetExtension(filename) == ".csv" || Path.GetExtension(filename) == ".CSV")
                {
                    ReportFormat bank   = ReportFormats.Where(r => r.IsChecked == true).First();
                    string       holder = HoldersItems.Where(r => r.IsChecked == true).Select(x => x.HolderName).First();
                    ExcelImport.ImportFromExcel(filename, bank, holder, date_statement.SelectedDate);
                    UpdateSalaries();
                    UpdateDataGrid();
                }
            }
        }
Example #2
0
        private void SalaryDate_SelectedDateChanged(object sender, EventArgs e)
        {
            Salary current_salary = new Salary();

            current_salary.Date   = new DateTime(Convert.ToDateTime(date_month.SelectedDate).Year, Convert.ToDateTime(date_month.SelectedDate).Month, 1);
            current_salary.Holder = HoldersItems.Where(r => r.IsChecked == true).Select(x => x.HolderName).First();
            txt_gross_salary.Text = current_salary.Get(false);
        }
Example #3
0
        public void Stacked_Chart(bool change)
        {
            DateTime from_month      = new DateTime();
            DateTime to_month        = new DateTime();
            string   selected_person = "";

            Dispatcher.Invoke(() =>
            {
                from_month      = new DateTime(Convert.ToDateTime(date_month_from.SelectedDate).Year, Convert.ToDateTime(date_month_from.SelectedDate).Month, 1);
                to_month        = Convert.ToDateTime(date_month_to.SelectedDate);
                selected_person = HoldersItems.Where(r => r.IsChecked == true).Select(x => x.HolderName).First();
                StackedSeriesCollection.Clear();
            });

            DataTable dt = BrokerageAsset.GetHistoricalInvestments(selected_person, null, null, from_month, to_month);

            IEnumerable <string> selectcategories = InvestmentCategory.Getcategories();

            Brush[] colors = { Brushes.DarkGreen, Brushes.ForestGreen, Brushes.Gainsboro, Brushes.DimGray, Brushes.Gold, Brushes.Orange, Brushes.DarkBlue };
            Dispatcher.Invoke(() =>
            {
                int count = 0;
                foreach (string category in selectcategories)
                {
                    ChartValues <DateModel> chartvalues = new ChartValues <DateModel>(dt.AsEnumerable().Where(r => r["category"].ToString() == category)
                                                                                      .Select(r => new DateModel {
                        DateTime = r.Field <DateTime>("date"), Value = r.Field <double?>("ending_mkt_value") ?? 0
                    }));
                    if (chartvalues.Count != 0)
                    {
                        StackedSeriesCollection.Add(new StackedColumnSeries
                        {
                            Values         = chartvalues,
                            StackMode      = StackMode.Values,
                            Title          = category,
                            Fill           = colors[count],
                            DataLabels     = true,
                            LabelPoint     = point => (point.Y / 1000).ToString("C1") + "k",
                            LabelsPosition = BarLabelPosition.Perpendicular,
                            Foreground     = Brushes.Black
                        });
                        count++;
                    }
                }
            });

            if (!change)
            {
                Dispatcher.Invoke(System.Windows.Threading.DispatcherPriority.DataBind, (Action)(() =>
                {
                    DataContext = this;
                }));
            }
        }
Example #4
0
 public void DisplayDefaultSalary()
 {
     if (HoldersItems != null)
     {
         Salary current_salary = new Salary();
         current_salary.Holder     = HoldersItems.Where(r => r.IsChecked == true).Select(x => x.HolderName).First();
         default_gross_salary.Text = current_salary.Get(true);
         if (default_gross_salary.Text == "")
         {
             default_gross_salary.Text = "0";
         }
     }
 }
Example #5
0
 public void SetSalaryDatepicker()
 {
     if (HoldersItems != null)
     {
         Salary currentsalary = new Salary();
         currentsalary.Holder = HoldersItems.Where(r => r.IsChecked == true).Select(x => x.HolderName).First();
         var salary_dates = currentsalary.GetDates();
         if (salary_dates != null)
         {
             date_month.DisplayDateStart = salary_dates.Item1;
             date_month.DisplayDateEnd   = salary_dates.Item2;
         }
     }
 }
Example #6
0
 private void SalaryButton_Click(object sender, RoutedEventArgs e)
 {
     if (!string.IsNullOrWhiteSpace(txt_gross_salary.Text) && date_month.SelectedDate != null)
     {
         Salary new_salary = new Salary();
         new_salary.Date   = new DateTime(Convert.ToDateTime(date_month.SelectedDate).Year, Convert.ToDateTime(date_month.SelectedDate).Month, 1);
         new_salary.Holder = HoldersItems.Where(r => r.IsChecked == true).Select(x => x.HolderName).First();
         new_salary.Amount = Math.Round(Convert.ToDouble(txt_gross_salary.Text), 2);
         new_salary.Delete();
         new_salary.Save();
         SetSalaryDatepicker();
         DisplayDefaultSalary();
     }
 }
Example #7
0
        public void MakeExpenseChart(bool change)
        {
            //bar chart
            MonthlyStatement statement = new MonthlyStatement();

            Dispatcher.Invoke(() =>
            {
                statement.holder         = HoldersItems.Where(r => r.IsChecked == true).Select(x => x.HolderName).First();
                statement.statement_date = Convert.ToDateTime(date_month.SelectedDate);
            });

            if (!change)
            {
                SeriesCollection_budget = new SeriesCollection();
            }

            Tuple <List <double>, List <double>, List <string> > result = statement.CompareMonths(statement.statement_date.AddMonths(-1));

            ChartValues <double> ChartValues_thismonth = new ChartValues <double>(result.Item1);
            ChartValues <double> ChartValues_lastmonth = new ChartValues <double>(result.Item2);
            List <string>        labels = result.Item3;

            Dispatcher.Invoke(() =>
            {
                ColumnSeries colseries_thismonth   = new ColumnSeries();
                colseries_thismonth.Title          = string.Format("{0:MMM yyyy}", statement.statement_date);
                colseries_thismonth.Values         = ChartValues_thismonth;
                colseries_thismonth.DataLabels     = true;
                colseries_thismonth.ColumnPadding  = 0;
                colseries_thismonth.MaxColumnWidth = 15;

                ColumnSeries colseries_lastmonth   = new ColumnSeries();
                colseries_lastmonth.Title          = string.Format("{0:MMM yyyy}", statement.statement_date.AddMonths(-1));
                colseries_lastmonth.Values         = ChartValues_lastmonth;
                colseries_lastmonth.ColumnPadding  = 0;
                colseries_lastmonth.MaxColumnWidth = 15;

                SeriesCollection_budget.Clear();
                SeriesCollection_budget.Add(colseries_thismonth);
                SeriesCollection_budget.Add(colseries_lastmonth);

                if (!change)
                {
                    Labels      = labels.ToArray();
                    Formatter   = value => value.ToString("C0");
                    DataContext = this;
                }
            });
        }
Example #8
0
        public void UpdateSalaries()
        {
            Salary new_salary = new Salary();

            new_salary.Holder = HoldersItems.Where(r => r.IsChecked == true).Select(x => x.HolderName).First();
            new_salary.Amount = Convert.ToDouble(default_gross_salary.Text);
            var salary_dates = new_salary.GetDates();

            if (salary_dates != null)
            {
                DateTime start_date = salary_dates.Item1;
                int      n_months   = ((salary_dates.Item2.Year - start_date.Year) * 12) + salary_dates.Item2.Month - start_date.Month + 1;

                for (int i = 1; i <= n_months; i++)
                {
                    new_salary.Date = start_date;
                    new_salary.Save();
                    start_date = start_date.AddMonths(1);
                }
            }
        }
Example #9
0
        public void PriceAsset_Chart(bool change, string _asset)
        {
            string asset = _asset;

            if (_asset == null)
            {
                asset = BrokerageAsset.GetFirstAsset();
            }
            DateTime from_month      = new DateTime();
            DateTime to_month        = new DateTime();
            string   selected_person = "";

            Dispatcher.Invoke(() =>
            {
                from_month      = new DateTime(Convert.ToDateTime(date_month_from.SelectedDate).Year, Convert.ToDateTime(date_month_from.SelectedDate).Month, 1);
                to_month        = Convert.ToDateTime(date_month_to.SelectedDate);
                selected_person = HoldersItems.Where(r => r.IsChecked == true).Select(x => x.HolderName).First();
                PriceSeriesCollection.Clear();
            });

            //stock price API
            ChartValues <DateModel> chartprices   = new ChartValues <DateModel>();
            ChartValues <DateModel> chartprices1  = new ChartValues <DateModel>();
            ChartValues <DateModel> chartprices2  = new ChartValues <DateModel>();
            ChartValues <DateModel> chartprices10 = new ChartValues <DateModel>();

            if (!new [] { "Treasuries", "Bonds", "CDs" }.Contains(asset))
            {
                order_history_formatter = "C2";
                string alphav_key = System.Web.Configuration.WebConfigurationManager.AppSettings["alphav_key"];
                if (alphav_key != null)
                {
                    string url_alphav_priceadj = "https://www.alphavantage.co/query?function=TIME_SERIES_DAILY_ADJUSTED&symbol=" + asset + "&apikey=" + alphav_key;
                    string results_timeseries  = "Time Series (Daily)";
                    if ((to_month - from_month).TotalDays > 95)
                    {
                        url_alphav_priceadj = "https://www.alphavantage.co/query?function=TIME_SERIES_WEEKLY_ADJUSTED&symbol=" + asset + "&apikey=" + alphav_key;
                        results_timeseries  = "Weekly Adjusted Time Series";
                    }
                    JObject json_results = (JObject)JsonConvert.DeserializeObject(Helpers.APIGet.GetAPIdata(url_alphav_priceadj));
                    if (json_results.First.ToString().Contains("Error Message"))
                    {
                        Dispatcher.Invoke(() =>
                        {
                            alert_APIerror.Visibility = Visibility.Visible;
                            alert_APIerror.Text       = "Security not found";
                        });
                    }
                    else if (json_results.First.ToString().Contains("Thank you for"))
                    {
                        Dispatcher.Invoke(() =>
                        {
                            alert_APIerror.Visibility = Visibility.Visible;
                            alert_APIerror.Text       = "API call limit reached (5 per min)";
                        });
                    }
                    else
                    {
                        Dispatcher.Invoke(() =>
                        {
                            alert_APIerror.Visibility = Visibility.Hidden;
                        });
                        foreach (JProperty date in json_results[results_timeseries])
                        {
                            if (Convert.ToDateTime(date.Name) <= to_month && Convert.ToDateTime(date.Name) >= from_month)
                            {
                                chartprices.Add(new DateModel {
                                    DateTime = Convert.ToDateTime(date.Name), Value = Convert.ToDouble(date.Value["5. adjusted close"])
                                });
                            }
                        }
                    }
                }
            }
            else
            {
                order_history_formatter = "P2";
                string      url_yields = "https://data.treasury.gov/feed.svc/DailyTreasuryYieldCurveRateData?$filter=year(NEW_DATE)%20gt%20" + (from_month.Year - 1);
                XmlDocument doc        = new XmlDocument();
                doc.LoadXml(Helpers.APIGet.GetAPIdata(url_yields));
                var nsmgr = new XmlNamespaceManager(doc.NameTable);
                nsmgr.AddNamespace("a", "http://www.w3.org/2005/Atom");
                nsmgr.AddNamespace("m", "http://schemas.microsoft.com/ado/2007/08/dataservices/metadata");
                nsmgr.AddNamespace("d", "http://schemas.microsoft.com/ado/2007/08/dataservices");
                foreach (XmlNode node in doc.DocumentElement.SelectNodes("a:entry/a:content", nsmgr))
                {
                    DateTime entry_date = Convert.ToDateTime(node.SelectSingleNode("m:properties/d:NEW_DATE", nsmgr).InnerText);
                    if ((to_month - from_month).TotalDays > 95 && entry_date.DayOfWeek != DayOfWeek.Friday)
                    {
                        continue;
                    }

                    if (entry_date >= from_month && entry_date <= to_month)
                    {
                        chartprices.Add(new DateModel {
                            DateTime = entry_date, Value = Convert.ToDouble(node.SelectSingleNode("m:properties/d:BC_3MONTH", nsmgr).InnerText) / 100
                        });
                        chartprices1.Add(new DateModel {
                            DateTime = entry_date, Value = Convert.ToDouble(node.SelectSingleNode("m:properties/d:BC_1YEAR", nsmgr).InnerText) / 100
                        });
                        chartprices2.Add(new DateModel {
                            DateTime = entry_date, Value = Convert.ToDouble(node.SelectSingleNode("m:properties/d:BC_2YEAR", nsmgr).InnerText) / 100
                        });
                        chartprices10.Add(new DateModel {
                            DateTime = entry_date, Value = Convert.ToDouble(node.SelectSingleNode("m:properties/d:BC_10YEAR", nsmgr).InnerText) / 100
                        });
                    }
                }
            }

            //database of past investment transactions
            string variable_sql   = (new [] { "Treasuries", "Bonds", "CDs" }.Contains(asset) ? "yield_to_maturity" : "price");
            string variable_label = (new [] { "Treasuries", "Bonds", "CDs" }.Contains(asset) ? "Yield" : "Price");

            Dispatcher.Invoke(() =>
            {
                gridstats.Children.Clear();

                if (chartprices.Count != 0)
                {
                    gridstats.Children.Add(Helpers.GridHelper.CreateTextInGrid("Latest " + variable_label + " (" + chartprices.AsEnumerable().OrderBy(r => r.DateTime).Last().DateTime.ToShortDateString()
                                                                               + "):", 2, 0));
                    gridstats.Children.Add(Helpers.GridHelper.CreateTextInGrid("Average " + variable_label + ":", 3, 0));
                    gridstats.Children.Add(Helpers.GridHelper.CreateTextInGrid("Minimum " + variable_label + ":", 4, 0));
                    gridstats.Children.Add(Helpers.GridHelper.CreateTextInGrid("Maximum " + variable_label + ":", 5, 0));

                    gridstats.Children.Add(Helpers.GridHelper.CreateTextInGrid(chartprices.AsEnumerable().OrderBy(r => r.DateTime).Last().Value.ToString(order_history_formatter), 2, 1));
                    gridstats.Children.Add(Helpers.GridHelper.CreateTextInGrid(chartprices.AsEnumerable().Average(r => r.Value).ToString(order_history_formatter), 3, 1));
                    gridstats.Children.Add(Helpers.GridHelper.CreateTextInGrid(chartprices.AsEnumerable().Min(r => r.Value).ToString(order_history_formatter), 4, 1));
                    gridstats.Children.Add(Helpers.GridHelper.CreateTextInGrid(chartprices.AsEnumerable().Max(r => r.Value).ToString(order_history_formatter), 5, 1));

                    PriceSeriesCollection.Add(new LineSeries
                    {
                        Values            = chartprices,
                        Title             = (new string[] { "Treasuries", "Bonds", "CDs" }.Contains(asset) ? "3MO T-Bill" : asset),
                        Foreground        = System.Windows.Media.Brushes.Black,
                        PointGeometrySize = 0
                    });


                    if (new string[] { "Treasuries", "Bonds", "CDs" }.Contains(asset))
                    {
                        gridstats.Children.Add(Helpers.GridHelper.CreateTextInGrid("3-Month:", 1, 1));

                        gridstats.Children.Add(Helpers.GridHelper.CreateTextInGrid("1-Year:", 1, 2));

                        gridstats.Children.Add(Helpers.GridHelper.CreateTextInGrid(chartprices1.AsEnumerable().OrderBy(r => r.DateTime).Last().Value.ToString(order_history_formatter), 2, 2));
                        gridstats.Children.Add(Helpers.GridHelper.CreateTextInGrid(chartprices1.AsEnumerable().Average(r => r.Value).ToString(order_history_formatter), 3, 2));
                        gridstats.Children.Add(Helpers.GridHelper.CreateTextInGrid(chartprices1.AsEnumerable().Min(r => r.Value).ToString(order_history_formatter), 4, 2));
                        gridstats.Children.Add(Helpers.GridHelper.CreateTextInGrid(chartprices1.AsEnumerable().Max(r => r.Value).ToString(order_history_formatter), 5, 2));

                        gridstats.Children.Add(Helpers.GridHelper.CreateTextInGrid("2-Year:", 1, 3));

                        gridstats.Children.Add(Helpers.GridHelper.CreateTextInGrid(chartprices2.AsEnumerable().OrderBy(r => r.DateTime).Last().Value.ToString(order_history_formatter), 2, 3));
                        gridstats.Children.Add(Helpers.GridHelper.CreateTextInGrid(chartprices2.AsEnumerable().Average(r => r.Value).ToString(order_history_formatter), 3, 3));
                        gridstats.Children.Add(Helpers.GridHelper.CreateTextInGrid(chartprices2.AsEnumerable().Min(r => r.Value).ToString(order_history_formatter), 4, 3));
                        gridstats.Children.Add(Helpers.GridHelper.CreateTextInGrid(chartprices2.AsEnumerable().Max(r => r.Value).ToString(order_history_formatter), 5, 3));

                        gridstats.Children.Add(Helpers.GridHelper.CreateTextInGrid("10-Year:", 1, 4));

                        gridstats.Children.Add(Helpers.GridHelper.CreateTextInGrid(chartprices10.AsEnumerable().OrderBy(r => r.DateTime).Last().Value.ToString(order_history_formatter), 2, 4));
                        gridstats.Children.Add(Helpers.GridHelper.CreateTextInGrid(chartprices10.AsEnumerable().Average(r => r.Value).ToString(order_history_formatter), 3, 4));
                        gridstats.Children.Add(Helpers.GridHelper.CreateTextInGrid(chartprices10.AsEnumerable().Min(r => r.Value).ToString(order_history_formatter), 4, 4));
                        gridstats.Children.Add(Helpers.GridHelper.CreateTextInGrid(chartprices10.AsEnumerable().Max(r => r.Value).ToString(order_history_formatter), 5, 4));

                        PriceSeriesCollection.Add(new LineSeries
                        {
                            Values            = chartprices1,
                            Title             = "1YR T-Bill",
                            Foreground        = System.Windows.Media.Brushes.Black,
                            PointGeometrySize = 0
                        });
                        PriceSeriesCollection.Add(new LineSeries
                        {
                            Values            = chartprices2,
                            Title             = "2YR T-Bill",
                            Foreground        = System.Windows.Media.Brushes.Black,
                            PointGeometrySize = 0
                        });
                        PriceSeriesCollection.Add(new LineSeries
                        {
                            Values            = chartprices10,
                            Title             = "10YR T-Bill",
                            Foreground        = System.Windows.Media.Brushes.Black,
                            PointGeometrySize = 0
                        });
                    }
                }
            });

            Dispatcher.Invoke(() =>
            {
                DataTable dt = BrokerageTransaction.GetHistoricalTransactions(asset, selected_person, from_month, to_month);
                if (dt.AsEnumerable().Where(r => r["transaction_description"].ToString().IndexOf("bought", StringComparison.OrdinalIgnoreCase) >= 0).Count() != 0 ||
                    dt.AsEnumerable().Where(r => r["transaction_description"].ToString().IndexOf("buy", StringComparison.OrdinalIgnoreCase) >= 0).Count() != 0)
                {
                    PriceSeriesCollection.Add(new ScatterSeries
                    {
                        Title  = "Bought",
                        Values = new ChartValues <DateModel>(dt.AsEnumerable().Where(r => r["transaction_description"].ToString().IndexOf("bought", StringComparison.OrdinalIgnoreCase) >= 0 ||
                                                                                     r["transaction_description"].ToString().IndexOf("buy", StringComparison.OrdinalIgnoreCase) >= 0)
                                                             .Select(r => new DateModel {
                            DateTime = r.Field <DateTime>("date"), Value = r.Field <double?>(variable_sql) ?? 0
                        }))
                    });
                    gridstats.Children.Add(Helpers.GridHelper.CreateTextInGrid("Average " + variable_label + " Bought:", 0, 0));
                    gridstats.Children.Add(Helpers.GridHelper.CreateTextInGrid(dt.AsEnumerable().Where(r => r["transaction_description"].ToString().IndexOf("bought", StringComparison.OrdinalIgnoreCase) >= 0 ||
                                                                                                       r["transaction_description"].ToString().IndexOf("buy", StringComparison.OrdinalIgnoreCase) >= 0)
                                                                               .Average(r => r.Field <double>(variable_sql)).ToString(order_history_formatter), 0, 1));
                }
                if (dt.AsEnumerable().Where(r => r["transaction_description"].ToString().IndexOf("sold", StringComparison.OrdinalIgnoreCase) >= 0).Count() != 0 ||
                    dt.AsEnumerable().Where(r => r["transaction_description"].ToString().IndexOf("sell", StringComparison.OrdinalIgnoreCase) >= 0).Count() != 0)
                {
                    PriceSeriesCollection.Add(new ScatterSeries
                    {
                        Title  = "Sold",
                        Values = new ChartValues <DateModel>(dt.AsEnumerable().Where(r => r["transaction_description"].ToString().IndexOf("sold", StringComparison.OrdinalIgnoreCase) >= 0 ||
                                                                                     r["transaction_description"].ToString().IndexOf("sell", StringComparison.OrdinalIgnoreCase) >= 0)
                                                             .Select(r => new DateModel {
                            DateTime = r.Field <DateTime>("date"), Value = r.Field <double?>(variable_sql) ?? 0
                        }))
                    });
                    gridstats.Children.Add(Helpers.GridHelper.CreateTextInGrid("Average " + variable_label + " Sold:", 0, 2));
                    gridstats.Children.Add(Helpers.GridHelper.CreateTextInGrid(dt.AsEnumerable().Where(r => r["transaction_description"].ToString().IndexOf("sold", StringComparison.OrdinalIgnoreCase) >= 0 ||
                                                                                                       r["transaction_description"].ToString().IndexOf("sell", StringComparison.OrdinalIgnoreCase) >= 0)
                                                                               .Average(r => r.Field <double>(variable_sql)).ToString(order_history_formatter), 0, 3));
                }
                label_assetclassprice.Text = asset + ": Order History and " + (new [] { "Treasuries", "Bonds", "CDs" }.Contains(asset) ? "Yields" : "Price (Adjusted For Splits and Dividends)");
                label_secstats.Text        = "Statistics for " + asset;
                PriceChart.DataContext     = this;
            });
        }
Example #10
0
        public void StackedAsset_Chart(bool change, string category)
        {
            DateTime from_month      = new DateTime();
            DateTime to_month        = new DateTime();
            string   selected_person = "";
            Regex    regex           = new Regex(@"\d{1,2}\/\d{1,2}\/\d{4}");

            Dispatcher.Invoke(() =>
            {
                label_assetclass.Text = category + " Allocation";

                from_month      = new DateTime(Convert.ToDateTime(date_month_from.SelectedDate).Year, Convert.ToDateTime(date_month_from.SelectedDate).Month, 1);
                to_month        = Convert.ToDateTime(date_month_to.SelectedDate);
                selected_person = HoldersItems.Where(r => r.IsChecked == true).Select(x => x.HolderName).First();
                StackedSeriesCollection2.Clear();
            });

            string    asset_column = (new [] { "Treasuries", "Bonds", "CDs" }.Contains(category) ? "asset_description" : "asset_symbol");
            DataTable dt           = BrokerageAsset.GetHistoricalInvestments(selected_person, category, asset_column, from_month, to_month);

            string[] assets = dt.AsEnumerable().Select(r => r[asset_column].ToString()).Distinct()
                              .OrderBy(s => (regex.IsMatch(s) ? Convert.ToDateTime(regex.Match(s).Value).ToString("yyyyMMdd") : s))
                              .ToArray();
            Dispatcher.Invoke(() =>
            {
                if (assets.Length > 8)
                {
                    chartStackedAsset.LegendLocation = LegendLocation.None;
                }
                else
                {
                    chartStackedAsset.LegendLocation = LegendLocation.Top;
                }

                foreach (string asset in assets)
                {
                    ChartValues <DateModel> chartvalues = new ChartValues <DateModel>(dt.AsEnumerable().Where(r => r[asset_column].ToString() == asset)
                                                                                      .Select(r => new DateModel {
                        DateTime = r.Field <DateTime>("date"), Value = r.Field <double?>("ending_mkt_value") ?? 0
                    }));
                    if (chartvalues.Count != 0)
                    {
                        StackedSeriesCollection2.Add(new StackedColumnSeries
                        {
                            Values         = chartvalues,
                            StackMode      = StackMode.Values,
                            Title          = (regex.IsMatch(asset) ? regex.Match(asset).Value : asset),
                            DataLabels     = (assets.Length > 8 ? false : true),
                            LabelPoint     = point => (point.Y / 1000).ToString("C1") + "k",
                            LabelsPosition = BarLabelPosition.Perpendicular,
                            Foreground     = System.Windows.Media.Brushes.Black
                        });
                    }
                }
            });

            if (!change)
            {
                Dispatcher.Invoke(System.Windows.Threading.DispatcherPriority.DataBind, (Action)(() =>
                {
                    DataContext = this;
                }));
            }
        }
        public void Make_Grid(bool change)
        {
            DataTable dt = new DataTable();
            string    selected_person = HoldersItems.Where(r => r.IsChecked == true).Select(x => x.HolderName).First();

            dt.Columns.Add("RowHeader");
            foreach (string rowheader in new [] { "Mean", "Median", "Standard Deviation" })
            {
                DataRow row = dt.NewRow();
                row["RowHeader"] = rowheader;
                dt.Rows.Add(row);
            }

            Dispatcher.Invoke(() => {
                DataGridAverage.DataContext = dt;
            });

            DateTime from_month = from_month = new DateTime(Convert.ToDateTime(date_month_from.SelectedDate).Year, Convert.ToDateTime(date_month_from.SelectedDate).Month, 1);
            DateTime to_month   = Convert.ToDateTime(date_month_to.SelectedDate);

            //savings
            Task saving_task = Task.Run(() =>
            {
                Tuple <string, string, string> mean_median_std = MonthlyStatement.GetHistoricalAggregateCategoryAmount("savings", selected_person, from_month, to_month);
                Dispatcher.Invoke(() => {
                    dt.Columns.Add("savings");

                    dt.Rows[0]["savings"] = mean_median_std.Item1;
                    dt.Rows[1]["savings"] = mean_median_std.Item2;
                    dt.Rows[2]["savings"] = mean_median_std.Item3;

                    DataGridAverage.DataContext = dt;
                });
            });

            //expenses
            Task expense_task = Task.Run(() =>
            {
                Tuple <string, string, string> mean_median_std = MonthlyStatement.GetHistoricalAggregateCategoryAmount("expenses", selected_person, from_month, to_month);
                Dispatcher.Invoke(() => {
                    dt.Columns.Add("expenses");

                    dt.Rows[0]["expenses"] = mean_median_std.Item1;
                    dt.Rows[1]["expenses"] = mean_median_std.Item2;
                    dt.Rows[2]["expenses"] = mean_median_std.Item3;

                    DataGridAverage.DataContext = dt;
                });
            });

            //categories
            Task categories_task = Task.Run(() =>
            {
                foreach (string category in BudgetCategory.GetCategories())
                {
                    if (category != "Miscellaneous" && !category.Contains("Investment"))
                    {
                        Tuple <string, string, string> mean_median_std = MonthlyStatement.GetHistoricalAggregateCategoryAmount(category, selected_person, from_month, to_month);
                        Dispatcher.Invoke(() => {
                            if (!change)
                            {
                                DataGridTextColumn c = new DataGridTextColumn();
                                c.Header             = category;
                                c.IsReadOnly         = true;
                                c.CellStyle          = (System.Windows.Style)FindResource("RightAlignment");
                                c.Binding            = new System.Windows.Data.Binding(category);
                                DataGridAverage.Columns.Add(c);
                            }

                            dt.Columns.Add(category);
                            dt.Rows[0][category] = mean_median_std.Item1;
                            dt.Rows[1][category] = mean_median_std.Item2;
                            dt.Rows[2][category] = mean_median_std.Item3;
                        });
                    }
                }
                Dispatcher.Invoke(() => {
                    DataGridAverage.DataContext = dt;
                });
            });

            tasks.Add(categories_task);
            tasks.Add(saving_task);
            tasks.Add(expense_task);
        }