private WorkoutPlan CreatePlanForExecutedWorkout(ExecutedWorkout lastExecutedWorkout)
{
var workoutPlan = new WorkoutPlan(lastExecutedWorkout.Workout, true);
var exercisesInWorkout = lastExecutedWorkout.Workout.Exercises.ToList();
var userSettings = GetUserSettings(lastExecutedWorkout.Workout.CreatedByUserId);
for (short x = 0; x < exercisesInWorkout.Count; x++)
{
var exerciseInWorkout = exercisesInWorkout[x];
//Find the ExercisePlan object from our new WorkoutPlan object for this exercise
var exercisePlan = workoutPlan.Exercises.First(x => x.Sequence == exerciseInWorkout.Sequence);
//Get the ExecutedExercises for this exercise from the last time this workout
//was performed
var exercisesFromLastTime =
lastExecutedWorkout
.Exercises
.Where(x => x.ExerciseId == exerciseInWorkout.ExerciseId);
exercisePlan.SetLastTimeValues(exercisesFromLastTime);
//If recommendations are enabled, apply them
if (userSettings != null && userSettings.RecommendationsEnabled)
{
var recommendation =
_recommendationService.GetRecommendation(
exerciseInWorkout.Exercise, lastExecutedWorkout, userSettings);
exercisePlan.ApplyRecommendation(recommendation);
}
}
return(workoutPlan);
}
public ExecutedWorkoutMetrics(ExecutedWorkout executedWorkout)
{
if (executedWorkout != null)
{
Name = executedWorkout.Workout.Name;
StartDateTime = executedWorkout.StartDateTime.Value;
EndDateTime = executedWorkout.EndDateTime.Value;
SetExecutedExerciseMetrics(executedWorkout.Exercises);
}
}
private static List <ExecutedExercise> GetLastSetsOfExercise(int exerciseId, ExecutedWorkout workout)
{
if (workout == null || workout.Exercises == null)
{
return(new List <ExecutedExercise>(0));
}
else
{
return(workout
.Exercises
.Where(exercise => exercise.ExerciseId == exerciseId)
.ToList());
}
}
public ActionResult <ExecutedWorkout> Put([FromBody] ExecutedWorkout value)
{
try
{
SetModifiedAuditFields(value);
return(_executedWorkoutService.Update(value, true));
}
catch (BadHttpRequestException ex)
{
return(BadRequest(ex));
}
catch (Exception ex)
{
return(StatusCode(500, ex.Message));
}
}
public WorkoutPlan Create(int workoutId, int userId)
{
try
{
ExecutedWorkout lastExecutedWorkout = _executedWorkoutService.GetLatest(workoutId);
if (lastExecutedWorkout == null)
{
return(CreatePlanForNewWorkout(workoutId, userId));
}
else
{
return(CreatePlanForExecutedWorkout(lastExecutedWorkout));
}
}
catch (Exception ex)
{
//TODO: Log
throw;
}
}
public void Should_Update_ExecutedWorkout()
{
//ARRANGE
var modifiedExecutedWorkout = new ExecutedWorkout();
byte numberOfExercises = 3;
modifiedExecutedWorkout.Exercises = new List <ExecutedExercise>(numberOfExercises);
for (byte x = 0; x < numberOfExercises; x++)
{
modifiedExecutedWorkout.Exercises.Add(new ExecutedExercise());
}
var workoutRepo = new Mock <IRepository <Workout> >(MockBehavior.Strict);
var executedWorkoutRepo = new Mock <IRepository <ExecutedWorkout> >(MockBehavior.Strict);
executedWorkoutRepo
.Setup(x => x.UpdateAsync <ExecutedWorkout>(modifiedExecutedWorkout, It.IsAny <Expression <Func <ExecutedWorkout, object> >[]>()))
.Returns(Task.FromResult(modifiedExecutedWorkout.Exercises.Count + 1));
var recommendationService = new Mock <IExerciseAmountRecommendationService>(MockBehavior.Strict);
var userService = new Mock <IUserService>(MockBehavior.Strict);
var sut =
new ExecutedWorkoutService(
executedWorkoutRepo.Object,
workoutRepo.Object,
recommendationService.Object,
userService.Object);
//ACT
var result = sut.Update(modifiedExecutedWorkout);
//ASSERT
result.ShouldBeSameAs(modifiedExecutedWorkout);
executedWorkoutRepo
.Verify(mock => mock.UpdateAsync(modifiedExecutedWorkout, It.IsAny <Expression <Func <ExecutedWorkout, object> >[]>()),
Times.Once);
}
/// <summary>
/// Gets an ExerciseAmountRecommendation for an exercise based on previous performance or lack thereof
/// </summary>
/// <param name="exercise">The Exercise to get an ExerciseAmountRecommendation for</param>
/// <param name="lastWorkoutWithThisExercise">The last ExecutedWorkout containing the Exercise to get a recommendation for</param>
/// <param name="userSettings">The settings for the user requesting the recommendation</param>
/// <returns>An ExerciseAmountRecommendation for the specified Exercise</returns>
public ExerciseAmountRecommendation GetRecommendation(
Exercise exercise,
ExecutedWorkout lastWorkoutWithThisExercise,
UserSettings userSettings = null)
{
if (exercise == null)
{
throw new ArgumentNullException(nameof(exercise));
}
var lastSetsOfThisExercise = GetLastSetsOfExercise(exercise.Id, lastWorkoutWithThisExercise);
if (userSettings == null)
{
userSettings = UserSettings.GetDefault(); //TODO: Remove stopgap.
}
if (UserHasPerformedExeriseBefore(lastWorkoutWithThisExercise))
{
if (UserHasPerformedExerciseRecently(lastSetsOfThisExercise))
{
//Adjust weights or reps accordingly
return(GetPerformanceBasedRecommendation(lastSetsOfThisExercise, userSettings));
}
else
{
//Recommend same as last time, or lower weights or rep if they
//did poorly
return(GetRecommendationForExerciseNotPerformedRecently(lastSetsOfThisExercise, userSettings));
}
}
else
{
//Exercise never performed. Start with the default recommendation values.
return(GetDefaultRecommendation(exercise));
}
}
public void Setup()
{
//TODO: Split up into smaller functions
var exercise1 =
_exerciseBuilder
.With(x => x.Id = 5)
.With(x => x.Name = "Exercise 1")
.Build();
var exercise2 =
_exerciseBuilder
.With(x => x.Id = 6)
.With(x => x.Name = "Exercise 2")
.Build();
var exercise3 =
_exerciseBuilder
.With(x => x.Id = 7)
.With(x => x.Name = "Exercise 3")
.Build();
var workout =
_workoutBuilder
.With(x => x.Exercises = new List <ExerciseInWorkout>(3)
{
_exerciseInWorkoutBuilder
.With(x => x.Exercise = exercise1)
.With(x => x.ExerciseId = exercise1.Id)
.With(x => x.Sequence = 1)
.Build(),
_exerciseInWorkoutBuilder
.With(x => x.Exercise = exercise2)
.With(x => x.ExerciseId = exercise2.Id)
.With(x => x.Sequence = 2)
.Build(),
_exerciseInWorkoutBuilder
.With(x => x.Exercise = exercise3)
.With(x => x.ExerciseId = exercise3.Id)
.With(x => x.Sequence = 3)
.Build()
})
.Build();
_executedWorkout =
_executedWorkoutBuilder
.With(x => x.Id = 5)
.With(x => x.Workout = workout)
.With(x => x.Exercises = new List <ExecutedExercise>(3)
{
_executedExerciseBuilder
.With(x => x.Exercise = exercise1)
.With(x => x.ExerciseId = exercise1.Id)
.With(x => x.ActualRepCount = 10)
.Build(),
_executedExerciseBuilder
.With(x => x.Exercise = exercise2)
.With(x => x.ExerciseId = exercise2.Id)
.Build(),
_executedExerciseBuilder
.With(x => x.Exercise = exercise3)
.With(x => x.ExerciseId = exercise3.Id)
.Build(),
})
.Build();
var user = new User();
user.Settings = new UserSettings();
user.Settings.RecommendationsEnabled = false;
_userServiceMock
.Setup(x => x.GetById(It.IsAny <int>()))
.Returns(user);
_sut = new WorkoutPlanService(
_workoutServiceMock.Object,
_executedWorkoutServiceMock.Object,
_userServiceMock.Object,
_recommendationServiceMock.Object);
}
private static bool UserHasPerformedExeriseBefore(ExecutedWorkout workout)
{
return(workout != null);
}
