Ejemplo n.º 1
0
        private async Task EditActionAsync(BindingTrainingExercise bindingTrainingExercise)
        {
            if (bindingTrainingExercise == null || bindingTrainingExercise.TrainingExercise == null)
            {
                return;
            }

            try
            {
                var trainingExercise = bindingTrainingExercise.TrainingExercise;
                var editTrainingExerciseViewModelResult = await EditTrainingExerciseViewModel.ShowAsync(trainingExercise, this);

                if (editTrainingExerciseViewModelResult != null && editTrainingExerciseViewModelResult.Result)
                {
                    var trainingDayKey = new TrainingDayKey()
                    {
                        UserId        = trainingExercise.UserId,
                        Year          = trainingExercise.Year,
                        WeekOfYear    = trainingExercise.WeekOfYear,
                        DayOfWeek     = trainingExercise.DayOfWeek,
                        TrainingDayId = trainingExercise.TrainingDayId
                    };
                    var trainingDay = _trainingDays.Where(t => TrainingDayKey.IsEqualByKey(t, trainingDayKey)).FirstOrDefault();
                    if (trainingDay != null)
                    {
                        var indexOfTrainingDay = _trainingDays.IndexOf(trainingDay);
                        //Reload local data
                        var trainingDayScenario = new TrainingDayScenario()
                        {
                            ManageExercise = true
                        };
                        trainingDay = _trainingDayService.GetTrainingDay(trainingDayKey, trainingDayScenario);
                        //Update trainingDay in list
                        _trainingDays[indexOfTrainingDay] = trainingDay;
                        //Update UI
                        CreateOrReplaceBindingTrainingDay(trainingDay);
                    }
                }
            }
            catch (Exception except)
            {
                ILogger.Instance.Error("Unable to edit training exercise set", except);
                await _userDialog.AlertAsync(except.Message, Translation.Get(TRS.ERROR), Translation.Get(TRS.OK));
            }
        }
Ejemplo n.º 2
0
        private async Task TrainingDayOrderActionAsync(BindingTrainingExercise bindingTrainingExercise, bool up)
        {
            if (bindingTrainingExercise == null || bindingTrainingExercise.TrainingExercise == null)
            {
                return;
            }

            try
            {
                var trainingExercise = bindingTrainingExercise.TrainingExercise;
                var trainingDayKey   = new TrainingDayKey()
                {
                    UserId        = trainingExercise.UserId,
                    Year          = trainingExercise.Year,
                    WeekOfYear    = trainingExercise.WeekOfYear,
                    DayOfWeek     = trainingExercise.DayOfWeek,
                    TrainingDayId = trainingExercise.TrainingDayId
                };
                var trainingDay        = _trainingDays.Where(t => TrainingDayKey.IsEqualByKey(t, trainingDayKey)).FirstOrDefault();
                var indexOfTrainingDay = _trainingDays.IndexOf(trainingDay);
                if (trainingDay != null)
                {
                    var indexOf = trainingDay.TrainingExercises.IndexOf(trainingExercise);
                    if (up && indexOf > 0)
                    { //up
                        trainingDay.TrainingExercises.Remove(trainingExercise);
                        trainingDay.TrainingExercises.Insert(indexOf - 1, trainingExercise);
                    }
                    if (!up && indexOf < (trainingDay.TrainingExercises.Count - 1))
                    { //down
                        trainingDay.TrainingExercises.Remove(trainingExercise);
                        trainingDay.TrainingExercises.Insert(indexOf + 1, trainingExercise);
                    }

                    indexOf = 1;
                    foreach (var trainingExerciseTmp in trainingDay.TrainingExercises)
                    {
                        trainingExerciseTmp.Id = indexOf;
                        indexOf++;
                    }

                    //Save in server
                    var trainingDayScenario = new TrainingDayScenario()
                    {
                        ManageExercise = true
                    };
                    trainingDay = await TrainingDayWebService.UpdateTrainingDayAsync(trainingDay, trainingDayScenario);

                    //Save in local database
                    _trainingDayService.UpdateTrainingDay(trainingDay, trainingDayScenario);
                    //Update trainingDay in list
                    _trainingDays[indexOfTrainingDay] = trainingDay;
                    //Update UI
                    CreateOrReplaceBindingTrainingDay(trainingDay);
                }
            }
            catch (Exception except)
            {
                ILogger.Instance.Error("Unable to order exercise", except);
                await _userDialog.AlertAsync(except.Message, Translation.Get(TRS.ERROR), Translation.Get(TRS.OK));
            }
        }
Ejemplo n.º 3
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));
            }
        }
Ejemplo n.º 4
0
        private GenericGroupModelCollection <BindingTrainingExercise> PopulateBindingTrainingDay(TrainingDay trainingDay)
        {
            if (trainingDay == null)
            {
                return(null);
            }

            string weightUnit = "kg";

            if (UserData.Instance.UserInfo.Unit == (int)TUnitType.Imperial)
            {
                weightUnit = Translation.Get(TRS.POUND);
            }

            StringBuilder           setRepSb = new StringBuilder();
            StringBuilder           setRepWeightSb = new StringBuilder();
            string                  formatSetRep = "{0} x {1}";
            string                  beginHourStr, endHourStr;
            BindingTrainingExercise bindingTrainingExercise;

            var collection = new GenericGroupModelCollection <BindingTrainingExercise>();;

            beginHourStr               = trainingDay.BeginHour.ToLocalTime().ToString("HH:mm");
            endHourStr                 = trainingDay.EndHour.ToLocalTime().ToString("HH:mm");
            collection.LongName        = string.Format("{0} {1} {2} {3}", Translation.Get(TRS.FROM), beginHourStr, Translation.Get(TRS.TO), endHourStr);
            collection.ShortName       = collection.LongName;
            collection.ReferenceObject = trainingDay;
            collection.Clear();

            if (trainingDay.TrainingExercises != null)
            {
                BodyExercise     bodyExercise;
                TrainingExercise trainingExercise;
                for (int i = 0; i < trainingDay.TrainingExercises.Count; i++)
                {
                    trainingExercise        = trainingDay.TrainingExercises[i];
                    bodyExercise            = _bodyExerciseList.Where(m => m.Id == trainingExercise.BodyExerciseId).FirstOrDefault();
                    bindingTrainingExercise = new BindingTrainingExercise()
                    {
                        TrainingExercise = trainingExercise,
                        BodyExerciseId   = trainingExercise.BodyExerciseId,
                        RestTime         = trainingExercise.RestTime,
                        Tempo            = string.Format("{0} : {1}-{2}-{3}-{4}", Translation.Get(TRS.TEMPO),
                                                         trainingExercise.EccentricContractionTempo,
                                                         trainingExercise.StretchPositionTempo,
                                                         trainingExercise.ConcentricContractionTempo,
                                                         trainingExercise.ContractedPositionTempo),
                        UpOrderVisible   = i != 0,
                        DownOrderVisible = i != (trainingDay.TrainingExercises.Count - 1)
                    };
                    bindingTrainingExercise.BodyExerciseName = bodyExercise != null ? bodyExercise.Name : Translation.Get(TRS.UNKNOWN);
                    if (trainingExercise.TrainingExerciseSets != null)
                    {
                        bindingTrainingExercise.SetRepsTitle       = string.Format(formatSetRep, Translation.Get(TRS.SETS), Translation.Get(TRS.REPS));
                        bindingTrainingExercise.SetRepWeightsTitle = Translation.Get(TRS.WEIGHT) + " (" + weightUnit + ")";
                        setRepSb.Clear();
                        setRepWeightSb.Clear();
                        foreach (var trainingExerciseSet in trainingExercise.TrainingExerciseSets)
                        {
                            setRepSb.AppendLine(string.Format(formatSetRep, trainingExerciseSet.NumberOfSets, trainingExerciseSet.NumberOfReps));
                            setRepWeightSb.AppendLine(trainingExerciseSet.Weight.ToString());
                        }
                        bindingTrainingExercise.SetReps       = setRepSb.ToString();
                        bindingTrainingExercise.SetRepWeights = setRepWeightSb.ToString();
                    }
                    collection.Add(bindingTrainingExercise);
                }
            }

            return(collection);
        }
        private GenericGroupModelCollection <BindingTrainingExercise> PopulateBindingTrainingDay(TrainingDay trainingDay)
        {
            if (trainingDay == null)
            {
                return(null);
            }

            TUnitType viewerUnit = UserData.Instance.UserInfo.Unit;
            string    weightUnit = viewerUnit == TUnitType.Imperial ? Translation.Get(TRS.POUND) : "kg";

            StringBuilder           setRepSb = new StringBuilder();
            StringBuilder           setRepWeightSb = new StringBuilder();
            string                  beginHourStr, endHourStr;
            BindingTrainingExercise bindingTrainingExercise;

            var collection = new GenericGroupModelCollection <BindingTrainingExercise>();;

            beginHourStr               = trainingDay.BeginHour.ToLocalTime().ToString("HH:mm");
            endHourStr                 = trainingDay.EndHour.ToLocalTime().ToString("HH:mm");
            collection.LongName        = $"{Translation.Get(TRS.FROM)} {beginHourStr} {Translation.Get(TRS.TO)} {endHourStr}";
            collection.ShortName       = collection.LongName;
            collection.ReferenceObject = trainingDay;
            collection.Clear();

            if (trainingDay.TrainingExercises != null)
            {
                BodyExercise     bodyExercise;
                TrainingExercise trainingExercise;
                for (int i = 0; i < trainingDay.TrainingExercises.Count; i++)
                {
                    trainingExercise        = trainingDay.TrainingExercises[i];
                    bodyExercise            = _bodyExerciseList.Where(m => m.Id == trainingExercise.BodyExerciseId).FirstOrDefault();
                    bindingTrainingExercise = new BindingTrainingExercise()
                    {
                        TrainingExercise = trainingExercise,
                        BodyExerciseId   = trainingExercise.BodyExerciseId,
                        RestTime         = trainingExercise.RestTime,
                        Tempo            = string.Format("{0} : {1}-{2}-{3}-{4}", Translation.Get(TRS.TEMPO),
                                                         trainingExercise.EccentricContractionTempo,
                                                         trainingExercise.StretchPositionTempo,
                                                         trainingExercise.ConcentricContractionTempo,
                                                         trainingExercise.ContractedPositionTempo),
                        UpOrderVisible   = i != 0,
                        DownOrderVisible = i != (trainingDay.TrainingExercises.Count - 1)
                    };
                    bindingTrainingExercise.BodyExerciseName = bodyExercise != null ? bodyExercise.Name : Translation.Get(TRS.UNKNOWN);
                    if (trainingExercise.TrainingExerciseSets != null)
                    {
                        bindingTrainingExercise.SetRepsTitle       = $"{Translation.Get(TRS.SETS)} x {(trainingExercise.ExerciseUnitType == TExerciseUnitType.RepetitionNumber ? Translation.Get(TRS.REPS) : Translation.Get(TRS.EXECUTION_TIME))}";
                        bindingTrainingExercise.SetRepWeightsTitle = Translation.Get(TRS.WEIGHT) + " (" + weightUnit + ")";
                        setRepSb.Clear();
                        setRepWeightSb.Clear();
                        foreach (var set in trainingExercise.TrainingExerciseSets)
                        {
                            setRepSb.AppendLine($"{set.NumberOfSets} x {(trainingExercise.ExerciseUnitType == TExerciseUnitType.RepetitionNumber ? set.NumberOfReps.ToString() : FormatExecutionTime(set.ExecutionTime))}");
                            setRepWeightSb.AppendLine(Math.Round(Utils.TransformWeightToUnitSytem(trainingDay.Unit, viewerUnit, set.Weight), 3).ToString());
                        }
                        bindingTrainingExercise.SetReps       = setRepSb.ToString();
                        bindingTrainingExercise.SetRepWeights = setRepWeightSb.ToString();
                    }
                    collection.Add(bindingTrainingExercise);
                }
            }

            return(collection);
        }