public async Task <ActionResult <WorkoutExercise> > PostWorkoutExercise(WorkoutExercise workoutExercise)
{
_context.WorkoutExercise.Add(workoutExercise);
await _context.SaveChangesAsync();
return(CreatedAtAction("GetWorkoutExercise", new { id = workoutExercise.Id }, workoutExercise));
}
public async Task <IActionResult> Edit(int id, [Bind("ExerciseId,WorkoutId,IsDeleted,DeletedOn,Id,CreatedOn,ModifiedOn")] WorkoutExercise workoutExercise)
{
if (id != workoutExercise.ExerciseId)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(workoutExercise);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!WorkoutExerciseExists(workoutExercise.ExerciseId))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
ViewData["ExerciseId"] = new SelectList(_context.Exercises, "Id", "Name", workoutExercise.ExerciseId);
ViewData["WorkoutId"] = new SelectList(_context.Workouts, "Id", "UserId", workoutExercise.WorkoutId);
return(View(workoutExercise));
}
public async Task <IActionResult> PutWorkoutExercise(int id, WorkoutExercise workoutExercise)
{
if (id != workoutExercise.Id)
{
return(BadRequest());
}
_context.Entry(workoutExercise).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!WorkoutExerciseExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
// WorkoutExercises
public async Task <WorkoutExercise> AddExerciseAsync(int workoutId, WorkoutExercise exercise)
{
exercise.WorkoutId = workoutId;
await db.WorkoutExercises.AddAsync(exercise);
return(exercise);
}
public bool ModifyExerciseChangeReps(WorkoutExercise e, ExerciseSetting exerciseSetting)
{
var reps = PickReps(exerciseSetting);
if (reps > 10)
{
if (e.Sets.All(x => x.Reps >= reps))
{
return(false);
}
}
else if (reps <= 10)
{
if (e.Sets.All(x => x.Reps < 10))
{
return(false);
}
}
e.Sets.Select(x =>
{
x.Reps = reps;
return(x);
}).ToList();
return(true);
}
private WorkoutHistory CloneWorkoutHistory(WorkoutHistory wh)
{
var workoutHistory = new WorkoutHistory();
foreach (var m in wh.MuscleExercises)
{
var me = new MuscleExercises {
MuscleType = m.MuscleType
};
foreach (var e in m.Exercises)
{
var ne = new WorkoutExercise {
Name = e.Name
};
foreach (var s in e.Sets)
{
ne.Sets.Add(new Set()
{
Reps = s.Reps, Rest = s.Rest
});
}
me.Exercises.Add(ne);
}
workoutHistory.MuscleExercises.Add(me);
}
return(workoutHistory);
}
/*
* public bool ModifyExerciseAddSet(WorkoutExercise e, int reps, double rest)
* {
* if (e.Sets.Count > 3)
* {
* return false;
* }
*
* var set = new Set() {Reps = reps, Rest = rest};
* if (reps < 10)
* e.Sets.Insert(0, set);
* else
* e.Sets.Add(set);
*
* return true;
* }
*
*/
public bool ModifyExerciseChangeSet(WorkoutExercise e, ExerciseSetting exerciseSetting)
{
Set set = null;
var reps = PickReps(exerciseSetting);
var rest = PickRest(exerciseSetting);
if (reps > 10)
{
if (e.Sets.All(x => x.Reps >= 10))
{
return(false);
}
set = e.Sets.Where(x => x.Reps < 10).Take(1).Single();
}
else if (reps <= 10)
{
if (e.Sets.All(x => x.Reps < 10))
{
return(false);
}
set = e.Sets.Where(x => x.Reps >= 10).Take(1).Single();
}
if (set == null)
{
return(false);
}
set.Reps = reps;
set.Rest = rest;
return(true);
}
public ActionResult DeleteExerciseConfirmed(int id, int workoutId)
{
WorkoutExercise workoutExercise = db.WorkoutExercises.Find(id);
db.WorkoutExercises.Remove(workoutExercise);
db.SaveChanges();
return(RedirectToAction("Details", new { id = workoutId }));
}
public async Task <WorkoutProgram> GetFullWorkoutLayout(int workoutID)
{
var service = new WorkoutService();
var program = new WorkoutProgram();
program.ID = workoutID;
program.Name = "blahhhh";
program.WorkoutDays = new List <WorkoutDay>();
List <FullWorkoutInfo> fullworkout = await service.GetFullWorkoutLayout(workoutID);
//group by workout day
var workoutDays = fullworkout.GroupBy(x => x.WorkoutDayTemplateID);
var workoutDayList = new List <WorkoutDay>();
foreach (var day in workoutDays)
{
var workoutDay = new WorkoutDay();
workoutDay.WorkoutDayID = day.Key;
workoutDay.Name = day.First().WorkoutDayTemplateName;
workoutDay.DayOrder = day.First().WorkoutDayTemplateDayOrder;
workoutDay.WorkoutExercises = new List <WorkoutExercise>();
//Group by exercise (in each workout day)
var workoutDayExercises = day.GroupBy(x => x.ExerciseID);
foreach (var exercise in workoutDayExercises)
{
var workoutExercise = new WorkoutExercise();
workoutExercise.ExerciseID = exercise.First().ExerciseID;
workoutExercise.ExerciseName = exercise.First().Exercise;
workoutExercise.ExerciseTypeID = exercise.First().ExerciseTypeID;
workoutExercise.ExerciseType = exercise.First().ExerciseType;
var setList = exercise.Select(x => new WorkoutSet
{
SetID = x.SetID,
Reps = x.Reps,
Weight = 0, //Calculate this later?
UseTM = x.UseTM.HasValue ? x.UseTM.Value : false,
TmPercent = x.TMPercent,
AMRAPSet = x.AMRAPSet.HasValue ? x.AMRAPSet.Value : false,
WarmupSet = x.WarmupSet.HasValue ? x.WarmupSet.Value : false
});
workoutExercise.ExerciseSets = setList;
workoutDay.WorkoutExercises.Add(workoutExercise);
}
workoutDayList.Add(workoutDay);
}
//order by day order
program.WorkoutDays = workoutDayList.OrderBy(x => x.DayOrder);
return(program);
}
public JsonResult SaveEx(WorkoutExercise exercise)
{
var message = cService.SaveWorkoutexercise(exercise);
return(new JsonResult()
{
Data = message, ContentEncoding = Encoding.UTF8
});
}
public void DeleteWorkoutExercise(WorkoutExercise workoutExercise)
{
WorkoutExercise workoutExerciseToDelete = FindWorkoutExercise(workoutExercise.WorkoutExerciseId);
if (workoutExerciseToDelete != null)
{
_entities.WorkoutExercises.Remove(workoutExercise);
_entities.SaveChanges();
}
}
public ActionResult Edit(WorkoutExercise workoutExercise)
{
if (ModelState.IsValid)
{
_workoutExerciseRepository.SaveWorkoutExercise(workoutExercise);
return(RedirectToAction("Index"));
}
return(View(workoutExercise));
}
private void LoadWorkoutExercise(WorkoutExercise workoutExercise)
{
WorkoutExerciseAdd = workoutExercise;
OnPropertyChanged("WorkoutExerciseAdd");
WorkoutAdd = WorkoutList.FirstOrDefault(p => p.Id == workoutExercise.WorkoutId);
OnPropertyChanged("WorkoutAdd");
ExerciseAdd = ExerciseList.FirstOrDefault(p => p.Id == workoutExercise.ExerciseId);
OnPropertyChanged("ExerciseAdd");
}
public List <WorkoutExercise> GetWorkoutExercisesByWorkoutId(int WorkoutId)
{
using (var connection = new SqlConnection(ConnectionString))
{
using (var command = new SqlCommand("GetWorkoutExercisesByWorkoutId", connection))
{
command.CommandType = CommandType.StoredProcedure;
List <WorkoutExercise> workoutExercises = new List <WorkoutExercise>();
SqlParameter parameter;
parameter = new SqlParameter
{
ParameterName = "@WorkoutId",
SqlDbType = SqlDbType.Int,
Direction = ParameterDirection.Input,
SqlValue = WorkoutId
};
command.Parameters.Add(parameter);
command.Connection.Open();
using (var dataReader = command.ExecuteReader())
{
if (dataReader.HasRows)
{
while (dataReader.Read())
{
WorkoutExercise workoutExercise = new WorkoutExercise
{
WorkoutExerciseId = dataReader.GetInt32("WorkoutExerciseId"),
WorkoutId = dataReader.GetInt32("WorkoutId"),
Exercise = GetExerciseById(dataReader.GetInt32("ExerciseId")),
Type = dataReader.GetString("Type"),
Rest = dataReader.GetInt32("Rest"),
Tempo = dataReader.IsDBNull("Tempo") ? null : dataReader.GetString("Tempo"),
RPE = dataReader.IsDBNull("RPE") ? null : (int?)dataReader.GetInt32("RPE"),
Order = dataReader.IsDBNull("Order") ? null : (int?)dataReader.GetInt32("Order"),
HasSuperset = dataReader.GetBoolean("HasSuperset"),
ExerciseSets = GetExerciseSetsByWorkoutExerciseId(dataReader.GetInt32("WorkoutExerciseId"))
};
if (workoutExercise.HasSuperset)
{
workoutExercise.SupersetExercise = GetSupersetExerciseByWorkoutExerciseId(workoutExercise.WorkoutExerciseId);
}
workoutExercises.Add(workoutExercise);
}
}
}
return(workoutExercises);
}
}
}
public ExerciseViewModel(WorkoutExercise exercise)
{
Id = exercise.Id;
Name = exercise.Name;
SetViewModels = exercise.Sets
.Select(x => new SetViewModel()
{
Rest = x.Rest,
Reps = x.Reps
}).ToList();
}
public bool ModifyExerciseChangeRest(WorkoutExercise e, ExerciseSetting exerciseSetting)
{
var rest = PickRest(exerciseSetting);
e.Sets.Select(x =>
{
x.Rest = rest;
return(x);
}).ToList();
return(true);
}
public WorkoutExerciseDto(WorkoutExercise model)
{
Id = model.ExerciseId;
Name = model.Exercise.Name;
Category = model.Exercise.Category;
Description = model.Exercise.Description;
ImagePath = model.Exercise.ImagePath;
Workouts = model.Exercise.Workouts;
Workshops = model.Exercise.Workshops;
DateTime = model.DateTime;
Sets = model.Sets;
}
public ActionResult Delete(int id)
{
WorkoutExercise workoutExerciseToDelete = _workoutExerciseRepository.FindWorkoutExercise(id);
if (workoutExerciseToDelete != null)
{
_workoutExerciseRepository.DeleteWorkoutExercise(workoutExerciseToDelete);
return(RedirectToAction("Index"));
}
return(HttpNotFound("Workout Exercise with specified id does not exist."));
}
public WorkoutExercise Post([FromBody] WorkoutExercise workoutExercise)
{
workoutExercise.WorkoutForeignKey = workoutExercise.workout.id;
workoutExercise.ExerciseForeignKey = workoutExercise.exercise.id;
workoutExercise.workout = null;
workoutExercise.exercise = null;
using (var context = new ApplicationDbContext())
{
context.WorkoutExercises.Add(workoutExercise);
context.SaveChanges();
}
return(workoutExercise);
}
public async Task <IActionResult> Create([Bind("ExerciseId,WorkoutId,IsDeleted,DeletedOn,Id,CreatedOn,ModifiedOn")] WorkoutExercise workoutExercise)
{
if (ModelState.IsValid)
{
_context.Add(workoutExercise);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
ViewData["ExerciseId"] = new SelectList(_context.Exercises, "Id", "Name", workoutExercise.ExerciseId);
ViewData["WorkoutId"] = new SelectList(_context.Workouts, "Id", "UserId", workoutExercise.WorkoutId);
return(View(workoutExercise));
}
public void GetExercise(int workoutId)
{
try
{
var Client = ExecuteHttpClient;
Exercises = WorkoutExercise.Where(w => w.WorkoutPlanId == workoutId)
.Select(s => s.Exercise).ToList();
}
catch (Exception e)
{
_logger.LogError(e, "Error in Get Exercise");
}
}
public WorkoutExerciseAddViewModel()
{
WorkoutExerciseAdd = new WorkoutExercise();
WorkoutExerciseList = new ObservableCollection <WorkoutExercise>(new WorkoutExerciseRepository().GetAll());
WorkoutList = new WorkoutRepository().GetAll().OrderByDescending(o => o.ExpirationDate).ToList();
ExerciseList = new ExerciseRepository().GetAll().OrderBy(o => o.Name).ToList();
WorkoutAdd = WorkoutList.FirstOrDefault();
ExerciseAdd = ExerciseList.FirstOrDefault();
SaveCommand = new Command(SaveWorkoutExercise);
LoadCommand = new Command <WorkoutExercise>(LoadWorkoutExercise);
DeleteCommand = new Command <WorkoutExercise>(DeleteWorkoutExercise);
}
private async Task AddWorkoutExercise(Exercise exercise)
{
var workoutExercise = new WorkoutExercise
{
ExerciseId = exercise.ExerciseId,
WorkoutId = App.Data.Workout.WorkoutId
};
if (!await WorkoutExerciseExist(workoutExercise))
{
await unitOfWork.Repository <WorkoutExercise>().Add(workoutExercise);
await unitOfWork.SaveChanges();
}
}
public ActionResult Edit(int id)
{
SetUser();
WorkoutExercise workoutExercise = _workoutExerciseRepository.FindWorkoutExercise(id);
ViewBag.ExercisesList = PopulateExercisesSelectList();
ViewBag.WorkoutsList = PopulateWorkoutSelectList();
if (workoutExercise != null)
{
return(View(workoutExercise));
}
return(HttpNotFound("Workout Exercise with specified id does not exist."));
}
public ActionResult DeleteWorkoutExercise(int id, int workoutId, int exerciseId, int repSetId, string notes, Exercise exercise, RepSet repSet, Workout workout, WorkoutExercise model)
{
WorkoutExercise workoutExercise = db.WorkoutExercises.Find(id);
if (workoutExercise == null)
{
return(HttpNotFound());
}
workoutExercise.Exercise = Repository.GetExerciseById(exerciseId);
workoutExercise.RepSet = Repository.GetRepSetById(repSetId);
workoutExercise.Workout = Repository.GetWorkoutById(workoutId);
workoutExercise.Notes = notes;
return(View(workoutExercise));
}
public ActionResult Add(int id, int exerciseId, int repSetId, string notes, Workout workout, WorkoutExercise model)
{
var workoutExercise = new WorkoutExercise()
{
//Id = Repository.GetWorkoutExerciseCount() + 1,
ExerciseId = exerciseId,
RepSetId = repSetId,
Notes = notes
//,
//WorkoutId = id
};
var workoutToUpdate = db.Workouts.FirstOrDefault(w => w.Id == id);
workoutToUpdate.AddExercise(exerciseId, repSetId, notes);
db.SaveChanges();
return(RedirectToAction("Details", new { Id = id }));
}
private void SaveWorkoutExercise()
{
WorkoutExerciseAdd.ExerciseId = ExerciseAdd.Id;
WorkoutExerciseAdd.WorkoutId = WorkoutAdd.Id;
if (WorkoutExerciseAdd.Id == 0)
{
new WorkoutExerciseRepository().Save(WorkoutExerciseAdd);
WorkoutExerciseList.Add(WorkoutExerciseAdd);
}
else
{
new WorkoutExerciseRepository().Update(WorkoutExerciseAdd);
WorkoutExerciseList = new ObservableCollection <WorkoutExercise>(new WorkoutExerciseRepository().GetAll());
OnPropertyChanged("WorkoutExerciseList");
}
WorkoutExerciseAdd = new WorkoutExercise();
OnPropertyChanged("WorkoutExerciseAdd");
}
public void DeleteWorkout(Workout workout)
{
Workout workoutToDelete = FindWorkout(workout.WorkoutId);
if (workoutToDelete != null)
{
WorkoutExercise[] workoutExercisesCopy = new WorkoutExercise[workoutToDelete.WorkoutExercises.Count];
workoutToDelete.WorkoutExercises.CopyTo(workoutExercisesCopy, 0);
foreach (WorkoutExercise w in workoutExercisesCopy)
{
_repository.WorkoutExercises.Remove(w);
}
workoutToDelete.Fk_UserId = null;
_repository.Workouts.Remove(workout);
_repository.SaveChanges();
}
}
public ActionResult EditWorkoutExercise(int id)
{
WorkoutExercise wExercise = db.WorkoutExercises.Find(id);
if (wExercise == null)
{
return(HttpNotFound());
}
var workoutExercise = new ViewModels.WorkoutViewModel();
workoutExercise.ExerciseList = Repository.GetExercises();
workoutExercise.RepSetList = Repository.GetRepSet();
workoutExercise.Id = wExercise.Id;
workoutExercise.ExerciseId = wExercise.ExerciseId;
workoutExercise.RepSetId = wExercise.RepSetId;
workoutExercise.WorkoutId = wExercise.WorkoutId;
workoutExercise.Notes = wExercise.Notes;
return(View(workoutExercise));
}
public async Task CreateAsync(List <ExerciseInputModel> exercises, string userId)
{
var workout = new Workout
{
Name = "Workout Day",
UserId = userId,
};
await this.workoutRepository.AddAsync(workout);
foreach (var exercise in exercises)
{
var exerciseId = this.exerciseRepository
.All()
.Where(x => x.Name == exercise.Name)
.Select(x => x.Id)
.FirstOrDefault();
if (exerciseId == 0)
{
throw new NullReferenceException();
}
var workoutExercise = new WorkoutExercise
{
Workout = workout,
ExerciseId = exerciseId,
Reps = exercise.Reps,
Sets = exercise.Sets,
Weight = exercise.Weight,
};
await this.workoutExerciseRepository.AddAsync(workoutExercise);
}
await this.workoutRepository.SaveChangesAsync();
await this.workoutExerciseRepository.SaveChangesAsync();
}
