private void CompleteTrainingDayWithExercise(TrainingDay trainingJournalDay)
 {
     if (trainingJournalDay != null)
     {
         var trainingExerciseCriteria = new TrainingExerciseCriteria()
         {
             UserId = new StringCriteria()
             {
                 Equal = trainingJournalDay.UserId
             },
             Year = new IntegerCriteria()
             {
                 Equal = trainingJournalDay.Year
             },
             WeekOfYear = new IntegerCriteria()
             {
                 Equal = trainingJournalDay.WeekOfYear
             },
             DayOfWeek = new IntegerCriteria()
             {
                 Equal = trainingJournalDay.DayOfWeek
             },
             TrainingDayId = new IntegerCriteria()
             {
                 Equal = trainingJournalDay.TrainingDayId
             }
         };
         var trainingExerciseService = new TrainingExerciseService(DbContext);
         trainingJournalDay.TrainingExercises = trainingExerciseService.FindTrainingExercise(trainingExerciseCriteria);
     }
 }
        internal TrainingDay UpdateTrainingDay(TrainingDay trainingDay, TrainingDayScenario trainingDayScenario)
        {
            TrainingDay trainingDayResult = null;

            trainingDayResult = _trainingDayModule.Update(trainingDay);

            if (trainingDayScenario != null && trainingDayScenario.ManageExercise)
            {
                var trainingExerciseService = new TrainingExerciseService(DbContext);

                var trainingExerciseCriteria = new TrainingExerciseCriteria()
                {
                    UserId = new StringCriteria()
                    {
                        Equal = trainingDay.UserId
                    },
                    Year = new IntegerCriteria()
                    {
                        Equal = trainingDay.Year
                    },
                    WeekOfYear = new IntegerCriteria()
                    {
                        Equal = trainingDay.WeekOfYear
                    },
                    DayOfWeek = new IntegerCriteria()
                    {
                        Equal = trainingDay.DayOfWeek
                    },
                    TrainingDayId = new IntegerCriteria()
                    {
                        Equal = trainingDay.TrainingDayId
                    }
                };
                var trainingExercisesDb = trainingExerciseService.FindTrainingExercise(trainingExerciseCriteria);
                if (trainingExercisesDb != null && trainingExercisesDb.Count > 0)
                {
                    foreach (var trainingExerciseDb in trainingExercisesDb)
                    {
                        trainingExerciseService.DeleteTrainingExercise(trainingExerciseDb);
                    }
                }

                if (trainingDay.TrainingExercises != null)
                {
                    trainingDayResult.TrainingExercises = new List <TrainingExercise>();
                    foreach (var trainingExercise in trainingDay.TrainingExercises)
                    {
                        trainingDayResult.TrainingExercises.Add(trainingExerciseService.UpdateTrainingExercise(trainingExercise, true));
                    }
                }
            }

            return(trainingDayResult);
        }
        internal TrainingDay CreateTrainingDay(TrainingDay trainingDay)
        {
            TrainingDay trainingDayResult = null;

            trainingDayResult = _trainingDayModule.Create(trainingDay);

            if (trainingDay.TrainingExercises != null)
            {
                var trainingExerciseService = new TrainingExerciseService(DbContext);
                trainingDayResult.TrainingExercises = new List <TrainingExercise>();
                foreach (var trainingExercise in trainingDay.TrainingExercises)
                {
                    trainingDayResult.TrainingExercises.Add(trainingExerciseService.CreateTrainingExercise(trainingExercise));
                }
            }

            return(trainingDayResult);
        }
        internal void DeleteTrainingDay(TrainingDayKey key)
        {
            var trainingDayScenario = new TrainingDayScenario()
            {
                ManageExercise = true
            };
            var trainingDay = GetTrainingDay(key, trainingDayScenario);

            if (trainingDay != null)
            {
                _trainingDayModule.Delete(trainingDay);

                if (trainingDay.TrainingExercises != null)
                {
                    var trainingExerciseService = new TrainingExerciseService(DbContext);
                    foreach (var trainingExercise in trainingDay.TrainingExercises)
                    {
                        trainingExerciseService.DeleteTrainingExercise(trainingExercise);
                    }
                }
            }
        }
Ejemplo n.º 5
0
        private async Task DeleteActionAsync(BindingTrainingExercise bindingTrainingExercise)
        {
            if (bindingTrainingExercise == null || bindingTrainingExercise.TrainingExercise == null)
            {
                return;
            }

            try
            {
                if (await _userDialog.ConfirmAsync(string.Format(Translation.Get(TRS.ARE_YOU_SURE_YOU_WANNA_DELETE_THIS_ELEMENT_PI), Translation.Get(TRS.TRAINING_EXERCISE)),
                                                   Translation.Get(TRS.QUESTION), Translation.Get(TRS.YES), Translation.Get(TRS.NO)))
                {
                    var trainingExercise = bindingTrainingExercise.TrainingExercise;
                    // Delete TrainingExercise on server
                    await TrainingExerciseWebService.DeleteTrainingExerciseAsync(trainingExercise);

                    // Delete TrainingExercise on local database
                    var trainingExerciseService = new TrainingExerciseService(_dbContext);
                    trainingExerciseService.DeleteTrainingExercise(trainingExercise);

                    //Remove trainingExercise in trainingDay
                    TrainingDay trainingDay = null;
                    foreach (var trainingDayTmp in _trainingDays)
                    {
                        if (trainingDayTmp.TrainingExercises == null)
                        {
                            continue;
                        }

                        if (trainingDayTmp.TrainingExercises.FirstOrDefault(t => t == trainingExercise) != null)
                        {
                            trainingDayTmp.TrainingExercises.Remove(trainingExercise);
                            trainingDay = trainingDayTmp;
                        }
                    }

                    //Refresh binding
                    if (GroupedTrainingExercises != null)
                    {
                        foreach (var gte in GroupedTrainingExercises)
                        {
                            if (gte.Contains(bindingTrainingExercise))
                            {
                                gte.Remove(bindingTrainingExercise);
                                break;
                            }
                        }
                    }

                    if (trainingDay != null)
                    {
                        PopulateBindingTrainingDay(trainingDay);
                    }
                }
            }
            catch (Exception except)
            {
                ILogger.Instance.Error("Unable to delete training exercise", except);
                await _userDialog.AlertAsync(except.Message, Translation.Get(TRS.ERROR), Translation.Get(TRS.OK));
            }
        }