private void BuildDayMusclesLookup()
        {
            var groupsOfDays = TrainingDays
                               .Where(x => x.Date.DayOfWeek == DayOfWeek.Monday ||
                                      x.Date.DayOfWeek == DayOfWeek.Wednesday ||
                                      x.Date.DayOfWeek == DayOfWeek.Friday)
                               .GroupBy(x => x.Date.DayOfWeek, x => x.Combos.SelectMany(y => y.Muscles));

            DayMusclesLookup = new Dictionary <DayOfWeek, string[]>();
            foreach (var group in groupsOfDays)
            {
                var musclesCount = group
                                   .GroupBy(x => x, new EnumerableStringEqualityComparer())
                                   .Select(x => new
                {
                    Muscles = x.Key.ToArray(),
                    Count   = x.Count()
                });

                string[] trueMuscles;
                if (musclesCount.Count() == 1)
                {
                    trueMuscles = musclesCount.First().Muscles;
                }
                else
                {
                    trueMuscles = musclesCount.Aggregate((curMax, x) => curMax == null || x.Count > curMax.Count ? x : curMax).Muscles;
                }

                DayMusclesLookup.Add(group.Key, trueMuscles);
            }
        }
        private void BuildAllCombos()
        {
            var groupsOfCombos = TrainingDays
                                 .SelectMany(x => x.Combos)
                                 .GroupBy(x => x.Name);

            var allCombos      = new List <Combo>();
            var mostUsedCombos = new List <Combo>();

            foreach (var group in groupsOfCombos)
            {
                var comboCount = group.GroupBy(x => x, new ComboEqualityComparer())
                                 .Select(x => new
                {
                    Combo = x.Key,
                    Count = x.Count()
                });

                Combo trueCombo;
                if (comboCount.Count() == 1)
                {
                    trueCombo = comboCount.First().Combo;
                }
                else
                {
                    trueCombo = comboCount.Aggregate((curMax, x) => curMax == null || x.Count > curMax.Count ? x : curMax).Combo;
                    mostUsedCombos.Add(trueCombo);
                }

                allCombos.Add(trueCombo);
            }

            AllCombos      = allCombos.ToDictionary(x => x.Name, x => x);
            MostUsedCombos = mostUsedCombos.OrderBy(x => x.Name).ToArray();
        }
Exemple #3
0
        private void Save()
        {
            var workbook = workbookHandler.getWorkbook(CurrentlySelectedTrainingDay.Year);

            if (SelectedTrainingDay != TrainingDays[TrainingDays.Count() - 1])
            {
                MessageBoxResult result = MessageBox.Show("Do you want to update this training session?", "Update", MessageBoxButton.YesNo);
                if (result == MessageBoxResult.No)
                {
                    return;
                }
                TrainingDataMapper.UpdateTraining(new TrainingModel(CurrentlySelectedTrainingDay, ExerciseList.ToList()), SelectedTrainingYear, SelectedTrainingMonth, TrainingPositionInMonth + 1, folderPath, "kk");
                MessageBox.Show("A training has been updated");
            }
            else
            {
                MessageBoxResult result = MessageBox.Show("Do you want to create new training session?", "Create", MessageBoxButton.YesNo);
                if (result == MessageBoxResult.No)
                {
                    return;
                }
                TrainingDataMapper.AddTraining(new TrainingModel(CurrentlySelectedTrainingDay, ExerciseList.ToList()), workbook);
                TrainingYears = TrainingDataMapper.GetTrainingYears(folderPath, "kk");
                MessageBox.Show("A new training has been saved");
                workbook.Save();
            }
        }
 private void BuildMuscleExercisesLookup()
 {
     MuscleExercisesLookup = TrainingDays
                             .SelectMany(x => x.Combos)
                             .SelectMany(x => x.Exercises)
                             .GroupBy(x => x.Muscle)
                             .ToDictionary(x => x.Key, x => x.GroupBy(y => y.Name).Select(y => y.Key).ToArray());
 }
        public Exercise GetPreviousExercise(string exerciseName, int skip = 0)
        {
            int foundCount = 0;

            foreach (var ex in TrainingDays.SelectMany(x => x.Combos).SelectMany(x => x.Exercises))
            {
                if (ex.Name == exerciseName)
                {
                    if (foundCount == skip)
                    {
                        return(ex);
                    }
                    foundCount++;
                }
            }
            return(null);
        }
        public IEnumerable <Combo> GetCombos(DayOfWeek day)
        {
            var muscles = DayMusclesLookup[day];

            foreach (var m in muscles)
            {
                var combos = MostUsedCombos
                             .Where(x => x.Muscles.Contains(m));

                var prevCombo = TrainingDays
                                .First(x => x.Combos.Any(y => y.Muscles.Contains(m)))
                                .Combos
                                .First(x => x.Muscles.Contains(m))
                                .Name;

                var combo = combos
                            .SkipWhile(x => x.Name != prevCombo)
                            .Skip(1)
                            .FirstOrDefault() ?? combos.First();

                yield return(combo);
            }
        }
Exemple #7
0
        private void Delete()
        {
            MessageBoxResult result = MessageBox.Show("Do you want to delete this training session?", "Delete", MessageBoxButton.YesNo);

            if (result == MessageBoxResult.No)
            {
                return;
            }

            var workbook = workbookHandler.getWorkbook(SelectedTrainingYear);

            if (SelectedTrainingDay != TrainingDays[TrainingDays.Count() - 1])
            {
                TrainingDataMapper.DeleteTraining(workbook.Worksheet(SelectedTrainingMonth.ToString()), TrainingPositionInMonth + 1);
                MessageBox.Show("A training has been deleted");
            }
            else
            {
                MessageBox.Show("Can't delete non-existing training");
            }

            workbook.Save();
        }