private void PopulateDatabase()
        {
            _context.SessionCounts.Add(new SessionCount
            {
                Id       = Guid.Parse("A9EF096F-9FB5-4408-B3FB-FF7F577D7C80"),
                NumOpen  = 1,
                NumClose = 0
            });

            _existingSession = new Session()
            {
                Id          = Guid.NewGuid(),
                DateCreated = DateTime.UtcNow,
                Status      = 1
            };

            _context.Sessions.Add(_existingSession);

            _existingSessionWord = new SessionWord()
            {
                SessionId   = _existingSession.Id,
                Word        = "vanilla",
                DateCreated = DateTime.UtcNow.AddDays(-1)
            };

            _context.SessionWords.Add(_existingSessionWord);

            _existingSessionWordCount = new SessionWordCount()
            {
                SessionId   = _existingSession.Id,
                Word        = "vanilla",
                Count       = 1,
                DateCreated = DateTime.UtcNow.AddDays(-1)
            };

            _context.SessionWordCounts.Add(_existingSessionWordCount);

            _existingWordDateCount = new WordDateCount()
            {
                Word        = "vanilla",
                Date        = DateTime.UtcNow.AddDays(-1),
                Count       = 1,
                DateCreated = DateTime.UtcNow.AddDays(-1)
            };

            _context.WordDateCounts.Add(_existingWordDateCount);

            _context.WorkerJobs.Add(new WorkerJob
            {
                ProcessId = 1,
                StartDate = DateTime.UtcNow.AddDays(-1),
                EndDate   = DateTime.UtcNow.AddDays(-1)
            });
            _context.SaveChanges();
        }
        private async Task UpdateVocabulary()
        {
            _viewModel.IsBusy    = true;
            _viewModel.TodayDate = DateTime.Now;


            List <VocabularyItem> vocabularyList =
                await ProgenyService.GetVocabularyList(_viewModel.ViewChild, _viewModel.UserAccessLevel, _viewModel.UserInfo.Timezone);

            _viewModel.VocabularyItems.ReplaceRange(vocabularyList);
            if (vocabularyList != null && vocabularyList.Count > 0)
            {
                vocabularyList = vocabularyList.OrderBy(v => v.Date).ToList();
                List <WordDateCount> dateTimesList = new List <WordDateCount>();
                int wordCount = 0;
                foreach (VocabularyItem vocabularyItem in vocabularyList)
                {
                    wordCount++;
                    if (vocabularyItem.Date != null)
                    {
                        if (dateTimesList.SingleOrDefault(d => d.WordDate.Date == vocabularyItem.Date.Value.Date) == null)
                        {
                            WordDateCount newDate = new WordDateCount();
                            newDate.WordDate  = vocabularyItem.Date.Value.Date;
                            newDate.WordCount = wordCount;
                            dateTimesList.Add(newDate);
                        }
                        else
                        {
                            WordDateCount wrdDateCount = dateTimesList.SingleOrDefault(d => d.WordDate.Date == vocabularyItem.Date.Value.Date);
                            if (wrdDateCount != null)
                            {
                                wrdDateCount.WordCount = wordCount;
                            }
                        }
                    }
                }

                LineSeries vocabularyLineSeries = new LineSeries()
                {
                    Color                 = OxyColors.DarkGreen,
                    MarkerType            = MarkerType.Circle,
                    MarkerSize            = 3,
                    MarkerStroke          = OxyColors.White,
                    MarkerFill            = OxyColors.Green,
                    MarkerStrokeThickness = 1.5,
                    Title                 = this.Title
                };

                StairStepSeries vocabularyStairStepSeries = new StairStepSeries()
                {
                    Color                 = OxyColors.DarkGreen,
                    MarkerType            = MarkerType.Circle,
                    MarkerSize            = 3,
                    MarkerStroke          = OxyColors.White,
                    MarkerFill            = OxyColors.Green,
                    MarkerStrokeThickness = 1.5,
                    Title                 = this.Title
                };

                StemSeries vocabularyStemSeries = new StemSeries()
                {
                    Color                 = OxyColors.DarkGreen,
                    MarkerType            = MarkerType.Circle,
                    MarkerSize            = 3,
                    MarkerStroke          = OxyColors.White,
                    MarkerFill            = OxyColors.Green,
                    MarkerStrokeThickness = 1.5,
                    Title                 = this.Title
                };

                double   maxCount      = 0;
                double   minCount      = 100000;
                DateTime firstWordDate = _viewModel.EndDate;
                DateTime lastWordDate  = _viewModel.StartDate;

                foreach (WordDateCount wordDateCount in dateTimesList)
                {
                    if (wordDateCount.WordDate >= StartDatePicker.Date && wordDateCount.WordDate <= EndDatePicker.Date)
                    {
                        double wordDateDouble = DateTimeAxis.ToDouble(wordDateCount.WordDate.Date);
                        vocabularyLineSeries.Points.Add(new DataPoint(wordDateDouble, wordDateCount.WordCount));
                        vocabularyStairStepSeries.Points.Add(new DataPoint(wordDateDouble, wordDateCount.WordCount));
                        vocabularyStemSeries.Points.Add(new DataPoint(wordDateDouble, wordDateCount.WordCount));

                        if (wordDateCount.WordCount > maxCount)
                        {
                            maxCount = wordDateCount.WordCount;
                        }

                        if (wordDateCount.WordCount < minCount)
                        {
                            minCount = wordDateCount.WordCount;
                        }
                    }
                    if (wordDateCount.WordDate < firstWordDate)
                    {
                        firstWordDate = wordDateCount.WordDate;
                    }

                    if (wordDateCount.WordDate > lastWordDate)
                    {
                        lastWordDate = wordDateCount.WordDate;
                    }
                }

                _viewModel.MinValue  = Math.Floor(minCount);
                _viewModel.MaxValue  = Math.Ceiling(maxCount);
                _viewModel.FirstDate = firstWordDate;
                _viewModel.LastDate  = lastWordDate;

                LinearAxis wordCountAxis = new LinearAxis();
                wordCountAxis.Key                = "WordCountAxis";
                wordCountAxis.Minimum            = 0;                   //_viewModel.MinValue -1;
                wordCountAxis.Maximum            = _viewModel.MaxValue; // + 1;
                wordCountAxis.Position           = AxisPosition.Left;
                wordCountAxis.MajorStep          = 10;
                wordCountAxis.MinorStep          = 5;
                wordCountAxis.MajorGridlineStyle = LineStyle.Solid;
                wordCountAxis.MinorGridlineStyle = LineStyle.Solid;
                wordCountAxis.MajorGridlineColor = OxyColor.FromRgb(200, 190, 170);
                wordCountAxis.MinorGridlineColor = OxyColor.FromRgb(250, 225, 205);
                wordCountAxis.AxislineColor      = OxyColor.FromRgb(0, 0, 0);

                DateTimeAxis dateAxis = new DateTimeAxis();
                dateAxis.Key                = "DateAxis";
                dateAxis.Minimum            = DateTimeAxis.ToDouble(StartDatePicker.Date);
                dateAxis.Maximum            = DateTimeAxis.ToDouble(EndDatePicker.Date);
                dateAxis.Position           = AxisPosition.Bottom;
                dateAxis.AxislineColor      = OxyColor.FromRgb(0, 0, 0);
                dateAxis.StringFormat       = "dd-MMM-yyyy";
                dateAxis.MajorGridlineStyle = LineStyle.Solid;
                dateAxis.MajorGridlineColor = OxyColor.FromRgb(230, 190, 190);
                dateAxis.IntervalType       = DateTimeIntervalType.Auto;
                dateAxis.FirstDayOfWeek     = DayOfWeek.Monday;
                dateAxis.MinorIntervalType  = DateTimeIntervalType.Auto;

                _viewModel.VocabularyPlotModel            = new PlotModel();
                _viewModel.VocabularyPlotModel.Background = OxyColors.White;
                _viewModel.VocabularyPlotModel.Axes.Add(wordCountAxis);
                _viewModel.VocabularyPlotModel.Axes.Add(dateAxis);
                _viewModel.VocabularyPlotModel.LegendPosition   = LegendPosition.TopLeft;
                _viewModel.VocabularyPlotModel.LegendBackground = OxyColors.LightYellow;

                if (ChartTypePicker.SelectedIndex == 0)
                {
                    _viewModel.VocabularyPlotModel.Series.Add(vocabularyLineSeries);
                }
                if (ChartTypePicker.SelectedIndex == 1)
                {
                    _viewModel.VocabularyPlotModel.Series.Add(vocabularyStairStepSeries);
                }
                if (ChartTypePicker.SelectedIndex == 2)
                {
                    _viewModel.VocabularyPlotModel.Series.Add(vocabularyStemSeries);
                }

                _viewModel.VocabularyPlotModel.InvalidatePlot(true);
            }


            _viewModel.IsBusy = false;
        }
        public async Task <IActionResult> Index(int childId = 0)
        {
            _progId = childId;
            string userEmail = HttpContext.User.FindFirst("email")?.Value ?? _defaultUser;

            UserInfo userinfo = await _progenyHttpClient.GetUserInfo(userEmail);

            if (childId == 0 && userinfo.ViewChild > 0)
            {
                _progId = userinfo.ViewChild;
            }
            if (_progId == 0)
            {
                _progId = Constants.DefaultChildId;
            }

            Progeny progeny = await _progenyHttpClient.GetProgeny(_progId);

            List <UserAccess> accessList = await _progenyHttpClient.GetProgenyAccessList(_progId);

            int userAccessLevel = (int)AccessLevel.Public;

            if (accessList.Count != 0)
            {
                UserAccess userAccess = accessList.SingleOrDefault(u => u.UserId.ToUpper() == userEmail.ToUpper());
                if (userAccess != null)
                {
                    userAccessLevel = userAccess.AccessLevel;
                }
            }

            if (progeny.IsInAdminList(userEmail))
            {
                _userIsProgenyAdmin = true;
                userAccessLevel     = (int)AccessLevel.Private;
            }

            List <VocabularyItemViewModel> model    = new List <VocabularyItemViewModel>();
            List <VocabularyItem>          wordList = await _progenyHttpClient.GetWordsList(_progId, userAccessLevel); // _context.VocabularyDb.Where(w => w.ProgenyId == _progId).ToList();

            wordList = wordList.OrderBy(w => w.Date).ToList();
            if (wordList.Count != 0)
            {
                foreach (VocabularyItem vocabularyItem in wordList)
                {
                    if (vocabularyItem.AccessLevel >= userAccessLevel)
                    {
                        VocabularyItemViewModel vocabularyItemViewModel = new VocabularyItemViewModel();
                        vocabularyItemViewModel.ProgenyId   = vocabularyItem.ProgenyId;
                        vocabularyItemViewModel.Date        = vocabularyItem.Date;
                        vocabularyItemViewModel.DateAdded   = vocabularyItem.DateAdded;
                        vocabularyItemViewModel.Description = vocabularyItem.Description;
                        vocabularyItemViewModel.Language    = vocabularyItem.Language;
                        vocabularyItemViewModel.SoundsLike  = vocabularyItem.SoundsLike;
                        vocabularyItemViewModel.Word        = vocabularyItem.Word;
                        vocabularyItemViewModel.IsAdmin     = _userIsProgenyAdmin;
                        vocabularyItemViewModel.WordId      = vocabularyItem.WordId;
                        model.Add(vocabularyItemViewModel);
                    }
                }
            }
            else
            {
                VocabularyItemViewModel vocabularyItemViewModel = new VocabularyItemViewModel();
                vocabularyItemViewModel.ProgenyId   = _progId;
                vocabularyItemViewModel.Date        = DateTime.UtcNow;
                vocabularyItemViewModel.DateAdded   = DateTime.UtcNow;
                vocabularyItemViewModel.Description = "The vocabulary list is empty.";
                vocabularyItemViewModel.Language    = "English";
                vocabularyItemViewModel.SoundsLike  = "";
                vocabularyItemViewModel.Word        = "No words found.";
                vocabularyItemViewModel.IsAdmin     = _userIsProgenyAdmin;
                model.Add(vocabularyItemViewModel);
            }

            model[0].Progeny = progeny;

            List <WordDateCount> dateTimesList = new List <WordDateCount>();
            int wordCount = 0;

            foreach (VocabularyItemViewModel vocabularyItemViewModel in model)
            {
                wordCount++;
                if (vocabularyItemViewModel.Date != null)
                {
                    if (dateTimesList.SingleOrDefault(d => d.WordDate.Date == vocabularyItemViewModel.Date.Value.Date) == null)
                    {
                        WordDateCount newDate = new WordDateCount();
                        newDate.WordDate  = vocabularyItemViewModel.Date.Value.Date;
                        newDate.WordCount = wordCount;
                        dateTimesList.Add(newDate);
                    }
                    else
                    {
                        WordDateCount wrdDateCount = dateTimesList.SingleOrDefault(d => d.WordDate.Date == vocabularyItemViewModel.Date.Value.Date);
                        if (wrdDateCount != null)
                        {
                            wrdDateCount.WordCount = wordCount;
                        }
                    }
                }
            }

            ViewBag.ChartData = dateTimesList;
            return(View(model));
        }