private void ValidateExerciseOrder(WorkoutExecutionDTO workoutExecutionDTO)
{
if (workoutExecutionDTO.Exercises.Count()
!= workoutExecutionDTO.Exercises.Select(x => x.Order).Distinct().Count())
{
throw new Exception("Orders are not distinct");
}
}
private void AddWorkoutPlanToCache(string username, WorkoutExecutionDTO workout)
{
var saveWorkouts = _workoutExecutionCacheService.Get(username)?.Value.ToList() ??
new List <WorkoutExecutionDTO>();
saveWorkouts.Add(workout);
_workoutExecutionCacheService.Put(username, saveWorkouts);
}
private void UpdateWorkoutInCache(string username, WorkoutExecutionDTO workout)
{
var workouts = _workoutExecutionCacheService.Get(username).Value;
var saveWorkouts = workouts.Where(x => x.ExternalId != workout.ExternalId)
.ToList();
saveWorkouts.Add(workout);
_workoutExecutionCacheService.Put(username, saveWorkouts);
}
public async Task AddWorkoutPlanAsync(string username, WorkoutExecutionDTO workout)
{
await ValidateWorkout(workout);
await _userRepository.AddUserIfNotExists(username);
AddWorkoutPlanToCache(username, workout);
_backgroundJobClientService.Enqueue <IAddWorkoutExecutionJob>(x => x.Run(username, workout));
}
private async Task ValidateFatigue(WorkoutExecutionDTO workoutExecutionDTO)
{
var fatigues = await _fatiguesRepository.GetAll();
if (!fatigues.Any(fatigue => fatigue.Id == workoutExecutionDTO.FatigueId))
{
throw new Exception("That fatigue does not exist");
}
}
private async Task ValidateMood(WorkoutExecutionDTO workoutExecutionDTO)
{
var moods = await _moodsRepository.GetAll();
if (!moods.Any(mood => mood.Id == workoutExecutionDTO.MoodId))
{
throw new Exception("That mood does not exist");
}
}
private async Task ValidateExercisesNamesAsync(WorkoutExecutionDTO workoutExecutionDTO)
{
var exercises = await _exerciseRepository.GetAllExercisesAsync();
if (!workoutExecutionDTO.Exercises.All(x => exercises.Any(y => y.Id == x.ExerciseId && y.Name == x.ExerciseName)))
{
throw new Exception("Invalid Exercises");
}
;
}
public async Task UpdateWorkoutPlanAsync(string username, WorkoutExecutionDTO workout)
{
await ValidateWorkout(workout);
if (!await UserWorkoutPlanExistsAsync(username, workout.ExternalId))
{
throw new Exception("there is no such workout");
}
;
UpdateWorkoutInCache(username, workout);
_backgroundJobClientService.Enqueue <IUpdateWorkoutExecutionJob>(x => x.Run(username, workout));
}
private Task SaveWorkout(Guid workoutExecutionId, string username, WorkoutExecutionDTO workoutExecutionDTO)
{
return(_sqlConnection.ExecuteAsync("[Workout].[sp_WorkoutExecutions_Add]", new
{
WorkoutName = workoutExecutionDTO.Name,
workoutExecutionDTO.IsPublic,
workoutExecutionDTO.Created,
workoutExecutionDTO.Description,
workoutExecutionDTO.ExternalId,
workoutExecutionDTO.FatigueId,
workoutExecutionDTO.MoodId,
workoutExecutionDTO.Executed,
Username = username,
WorkouExecutionVersionId = workoutExecutionId,
IsActive = true,
},
commandType: CommandType.StoredProcedure));
}
public async Task Run(string username, WorkoutExecutionDTO workoutExecutionDTO)
{
await _commandDispatcher.Dispatch(new AddWorkoutExecutionCommand { Username = username, Workout = workoutExecutionDTO }, default);
}
private async Task ValidateExercisesAsync(WorkoutExecutionDTO workoutExecutionDTO)
{
ValidateExerciseOrder(workoutExecutionDTO);
await ValidateExercisesNamesAsync(workoutExecutionDTO);
}
private Task ValidateWorkout(WorkoutExecutionDTO workoutExecutionDTO)
{
return(Task.WhenAll(ValidateExercisesAsync(workoutExecutionDTO), ValidateFatigue(workoutExecutionDTO), ValidateMood(workoutExecutionDTO)));
}
