public ExerciseAmountRecommendation(ExecutedExercise executedExercise)
{
if (executedExercise == null)
{
throw new ArgumentNullException(nameof(executedExercise));
}
ExerciseId = executedExercise.Exercise.Id;
ResistanceAmount = executedExercise.ResistanceAmount;
ResistanceMakeup = executedExercise.ResistanceMakeup;
Reps = executedExercise.TargetRepCount;
}
private ExecutedWorkout CreateFromPlan(WorkoutPlan workoutPlan, DateTime?startDateTime, DateTime?endDateTime)
{
var executedWorkout = new ExecutedWorkout();
executedWorkout.WorkoutId = workoutPlan.WorkoutId;
executedWorkout.CreatedByUserId = workoutPlan.UserId;
executedWorkout.Exercises = new List <ExecutedExercise>(); //TODO: Initialize by known size
var workout = _workoutRepo.Get(workoutPlan.WorkoutId);
byte exerciseSequence = 0;
foreach (var exerciseInWorkout in workout.Exercises?.OrderBy(x => x.Sequence))
{
//Find the ExercisePlan in the submitted WorkoutPlan for this exercise
var exercisePlan = workoutPlan.Exercises.First(exPlan => exPlan.ExerciseId == exerciseInWorkout.ExerciseId);
for (byte x = 0; x < exerciseInWorkout.NumberOfSets; x++)
{
//TODO: Add new constructor to ExecutedExercise which takes an ExercisePlan param
//and initialize that way instead.
var exerciseToExecute = new ExecutedExercise();
exerciseToExecute.CreatedByUserId = workout.CreatedByUserId;
exerciseToExecute.CreatedDateTime = workoutPlan.SubmittedDateTime.Value;
exerciseToExecute.Exercise = exerciseInWorkout.Exercise;
exerciseToExecute.ExerciseId = exerciseInWorkout.Exercise.Id;
exerciseToExecute.Sequence = exerciseSequence;
exerciseToExecute.SetType = exerciseInWorkout.SetType;
exerciseToExecute.TargetRepCount = exercisePlan.TargetRepCount;
exerciseToExecute.ResistanceAmount = exercisePlan.ResistanceAmount;
exerciseToExecute.ResistanceMakeup = exercisePlan.ResistanceMakeup;
executedWorkout.Exercises.Add(exerciseToExecute);
exerciseSequence++;
}
}
executedWorkout.StartDateTime = startDateTime;
executedWorkout.EndDateTime = endDateTime;
_repo.Add(executedWorkout, true);
return(executedWorkout);
}
/// <summary>
/// Provides an adjustment recommendation for an exercise. This adjustment will suggest to decrease
/// the resistance amount and/or target reps.
/// </summary>
/// <param name="executedExercise">The exercise which needs adjustment</param>
/// <param name="userSettings">The user's settings</param>
/// <returns>An ExerciseAmountRecommendation with recommendations regarding reps and resistance</returns>
public ExerciseAmountRecommendation GetAdjustmentRecommendation(
ExecutedExercise executedExercise,
UserSettings userSettings)
{
//Adjust target reps, resistance, or both.
if (executedExercise == null)
{
throw new ArgumentNullException(nameof(executedExercise));
}
if (userSettings == null)
{
throw new ArgumentNullException(nameof(userSettings));
}
ExerciseAmountRecommendation recommendation;
bool inadequateForm = !HadAdequateRating(executedExercise.FormRating);
bool inadequateRangeOfMotion = !HadAdequateRating(executedExercise.RangeOfMotionRating);
bool actualRepsSignificantlyLessThanTarget = ActualRepsSignificantlyLessThanTarget(executedExercise.SetType, executedExercise.TargetRepCount, executedExercise.ActualRepCount);
bool actualRepsLessThanTarget = ActualRepsLessThanTarget(executedExercise.SetType, executedExercise.TargetRepCount, executedExercise.ActualRepCount);
//If form or range of motion was lacking, reduce resistance.
if (inadequateForm || inadequateRangeOfMotion || actualRepsSignificantlyLessThanTarget || actualRepsLessThanTarget)
{
recommendation =
GetDecreaseRecommendation(
executedExercise,
userSettings,
inadequateForm,
inadequateRangeOfMotion,
actualRepsSignificantlyLessThanTarget,
actualRepsLessThanTarget);
}
//Otherwise, they didn't meet their goals last time, but they should remain the same.
else
{
recommendation = new ExerciseAmountRecommendation(executedExercise);
recommendation.Reason = "";
}
return(recommendation);
}
private ExerciseAmountRecommendation GetTimedSetIncreaseRecommendation(
ExecutedExercise executedExercise,
UserSettings userSettings)
{
var recommendation = new ExerciseAmountRecommendation();
var repSettings =
GetRepSettings(
userSettings.RepSettings,
executedExercise.SetType,
executedExercise.Duration);
//Increase reps or resistance?
if (executedExercise.ActualRepCount >= repSettings.MaxReps)
{
//User met or exceeded max reps. Let's bump up the resistance and set reps to min.
string resistanceMakeup;
recommendation.Reps = repSettings.MinReps;
recommendation.ResistanceAmount =
GetIncreasedResistanceAmount(
executedExercise.TargetRepCount,
executedExercise.ActualRepCount,
executedExercise.ResistanceAmount,
executedExercise.Exercise,
out resistanceMakeup);
recommendation.ResistanceMakeup = resistanceMakeup;
}
else
{
//Increase reps, but keep resistance amounts the same.
recommendation.Reps =
GetIncreasedTargetRepCount(
executedExercise.TargetRepCount,
executedExercise.ActualRepCount,
repSettings.MaxReps);
recommendation.ResistanceAmount = executedExercise.ResistanceAmount;
recommendation.ResistanceMakeup = executedExercise.ResistanceMakeup; //TODO: Add constructor to recommendation to default this stuff from an ExecutedExercise
}
return(recommendation);
}
private ExerciseAmountRecommendation GetRepititionSetIncreaseRecommendation(
ExecutedExercise executedExercise)
{
var recommendation = new ExerciseAmountRecommendation();
//For repitition sets, we'll increase the resistance amount
string resistanceMakeup;
recommendation.Reps = executedExercise.TargetRepCount;
recommendation.ResistanceAmount =
GetIncreasedResistanceAmount(
executedExercise.TargetRepCount,
executedExercise.ActualRepCount,
executedExercise.ResistanceAmount,
executedExercise.Exercise,
out resistanceMakeup);
recommendation.ResistanceMakeup = resistanceMakeup;
return(recommendation);
}
public ExerciseAmountRecommendation GetIncreaseRecommendation(
ExecutedExercise executedExercise,
UserSettings userSettings)
{
if (executedExercise == null)
{
throw new ArgumentNullException(nameof(executedExercise));
}
if (userSettings == null)
{
throw new ArgumentNullException(nameof(userSettings));
}
if (executedExercise.SetType == SetType.Timed)
{
return(GetTimedSetIncreaseRecommendation(executedExercise, userSettings));
}
else //Repititon set
{
return(GetRepititionSetIncreaseRecommendation(executedExercise));
}
}
/// <summary>
/// Gets a recommendation to decrease something about an exercise.
/// </summary>
/// <param name="executedExercise">The exercise which was executed and needs a decrease in reps or resistance</param>
/// <param name="userSettings">The user's settings</param>
/// <param name="inadequateForm">Indicates whether or not the exercise was last performed with inadequate form</param>
/// <param name="inadequateRangeOfMotion">Indicates whether or not the exercise was last performed with inadequate range of motion</param>
/// <param name="actualRepsSignificantlyLessThanTarget">Indicates whether or not the exercise was last performed with significantly less reps that targeted</param>
/// <param name="actualRepsLessThanTarget">Indicates whether or not the exercise was last performed with less reps that targeted</param>
/// <returns>An ExerciseAmountRecommendation with recommendations regarding reps and resistance</returns>
/// <remarks>
/// This abstracts the differences between getting a decrease recommendation for an exercise for a
/// timed set versus a repetition set.
/// </remarks>
private ExerciseAmountRecommendation GetDecreaseRecommendation(
ExecutedExercise executedExercise,
UserSettings userSettings,
bool inadequateForm,
bool inadequateRangeOfMotion,
bool actualRepsSignificantlyLessThanTarget,
bool actualRepsLessThanTarget)
{
/*
* If form and/or range of motion were inadequate, lower resistance.
* If reps were less than target, decrease target.
*/
string resistanceMakeup;
bool recommendingDecreasedResistance = false;
var recommendation = new ExerciseAmountRecommendation(executedExercise);
if (inadequateForm || inadequateRangeOfMotion) //Because we have both, we can make this more granular later if need be
{
recommendingDecreasedResistance = true;
recommendation.ResistanceAmount =
GetDecreasedResistanceAmount(
executedExercise.SetType,
executedExercise.TargetRepCount,
executedExercise.ActualRepCount,
executedExercise.ResistanceAmount,
executedExercise.Exercise,
out resistanceMakeup);
recommendation.ResistanceMakeup = resistanceMakeup;
}
if (ShouldRepCountBeLowered(actualRepsLessThanTarget, recommendingDecreasedResistance, actualRepsSignificantlyLessThanTarget))
{
recommendation.Reps = GetDecreasedRepCount(executedExercise.SetType, userSettings, executedExercise.TargetRepCount, executedExercise.ActualRepCount);
}
return(recommendation);
}
