public async Task <IActionResult> Post(int workoutId, WorkoutExerciseModel exerciseModel)
{
try
{
var userId = User.GetUserId();
var workout = await workoutRepository.GetWorkoutByIdAsync(userId, workoutId);
if (workout == null)
{
return(NotFound("No workout was found"));
}
var exercise = mapper.Map <WorkoutExercise>(exerciseModel);
await workoutRepository.AddExerciseAsync(workoutId, exercise);
if (await workoutRepository.CommitAsync())
{
exerciseModel = mapper.Map <WorkoutExerciseModel>(exercise);
return(Ok(exerciseModel));
}
return(BadRequest("Unable to add exercise to workout"));
}
catch (Exception)
{
throw;
// return StatusCode(StatusCodes.Status500InternalServerError, "Internal Server Error");
}
}
async Task AddExercise()
{
try
{
if (Workout.WorkoutExercises.Count() > 0)
{
var lastOrder = Workout.WorkoutExercises.Max(w => w.OrderInt);
ExerciseToAdd.OrderInt = lastOrder + 1;
}
else
{
ExerciseToAdd.OrderInt = 1;
}
var response = await WorkoutService.AddExerciseToWorkoutAsync(Workout.Id, ExerciseToAdd);
if (response.IsSuccessStatusCode)
{
//Workout = await woService.GetWorkoutByIdAsync(WorkoutId);
await OnInitializedAsync();
ExerciseToAdd = new WorkoutExerciseModel();
}
else
{
Message = await response.Content.ReadAsStringAsync();
}
}
catch (Exception)
{
throw;
}
}
public async Task <IActionResult> Put(int workoutId, int exerciseId, WorkoutExerciseModel updatedExercise)
{
try
{
var userId = User.GetUserId();
var workout = await workoutRepository.GetWorkoutByIdAsync(userId, workoutId);
if (workout == null)
{
return(BadRequest("Workout not found"));
}
var exerciseToUpdate = workout.WorkoutExercises.Where(we => we.Id == exerciseId).FirstOrDefault();
if (exerciseToUpdate == null)
{
return(NotFound("Exercise not found"));
}
// fix as mapper is erroring
exerciseToUpdate.RepScheme = updatedExercise.RepScheme;
exerciseToUpdate.Sets = updatedExercise.Sets;
exerciseToUpdate.Rest = updatedExercise.Rest;
exerciseToUpdate.OrderString = updatedExercise.OrderString;
exerciseToUpdate.Notes = updatedExercise.Notes;
//mapper.Map(updatedExercise, exerciseToUpdate);
if (await workoutRepository.CommitAsync())
{
return(Ok(updatedExercise));
}
return(BadRequest("bad Request"));
}
catch (Exception)
{
return(StatusCode(StatusCodes.Status500InternalServerError, "Internal Server Error"));
}
}
async Task ListUpdated(WorkoutExerciseModel exerciseDroppedOn)
{
var indexOfStart = WorkoutExercises.FindIndex(e => e.Id == DraggedItem.Id);
var indexOfDrop = WorkoutExercises.FindIndex(e => e.Id == exerciseDroppedOn.Id);
WorkoutExercises.RemoveAt((indexOfStart));
WorkoutExercises.Insert(indexOfDrop, DraggedItem);
if (indexOfStart != indexOfDrop)
{
foreach (var exercise in WorkoutExercises)
{
exercise.OrderInt = (WorkoutExercises.FindIndex(e => e.Id == exercise.Id)) + 1;
}
var response = await WorkoutService.UpdateExerciseOrder(WorkoutId, WorkoutExercises);
if (!response.IsSuccessStatusCode)
{
Message = "Unable to update database";
}
}
}
public async Task <HttpResponseMessage> RemoveExerciseAsync(int workoutId, WorkoutExerciseModel exercise)
{
return(await http.DeleteAsync($"/api/workouts/{workoutId}/exercises/{exercise.Id}"));
}
public async Task <HttpResponseMessage> UpdateExerciseAsync(int workoutId, WorkoutExerciseModel exercise)
{
return(await http.PutAsJsonAsync($"/api/workouts/{workoutId}/exercises/{exercise.Id}", exercise));
}
// workout exercise services
public async Task <HttpResponseMessage> AddExerciseToWorkoutAsync(int workoutId, WorkoutExerciseModel exercise)
{
return(await http.PostAsJsonAsync($"/api/workouts/{workoutId}/exercises", exercise));
}
void ItemBeingDragged(WorkoutExerciseModel excercise)
{
DraggedItem = excercise;
}
void UpdateExerciseToDelete(WorkoutExerciseModel exercise)
{
ExerciseToDelete = exercise;
}
