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(); }