protected override void OnModelCreating(ModelBuilder modelBuilder)
{
var testPlan = new Plan
{
Id = 1,
Name = "TestPlan"
};
var mondayWorkOutDay = new WorkoutDay()
{
Id = 1,
DayOfWeek = DayOfWeek.Monday,
MuscleGroup = MuscleGroup.Back,
PlanId = testPlan.Id
};
var fridayWorkOutDay = new WorkoutDay()
{
Id = 2,
DayOfWeek = DayOfWeek.Friday,
MuscleGroup = MuscleGroup.Body,
PlanId = testPlan.Id
};
var pussUpsExercise = new Exercise()
{
Id = 1,
Name = "Push-ups",
RestTime = new TimeSpan(0, 0, 30),
WorkoutDayId = mondayWorkOutDay.Id
};
var repeat1 = new Repeat()
{
Id = 1,
Number = 1,
Count = 5,
ExerciseId = pussUpsExercise.Id
};
var repeat2 = new Repeat()
{
Id = 2,
Number = 2,
Count = 10,
ExerciseId = pussUpsExercise.Id
};
var repeat3 = new Repeat()
{
Id = 3,
Number = 3,
Count = 15,
ExerciseId = pussUpsExercise.Id
};
modelBuilder.Entity <Plan>().HasData(testPlan);
modelBuilder.Entity <WorkoutDay>().HasData(mondayWorkOutDay, fridayWorkOutDay);
modelBuilder.Entity <Exercise>().HasData(pussUpsExercise);
modelBuilder.Entity <Repeat>().HasData(repeat1, repeat2, repeat3);
base.OnModelCreating(modelBuilder);
}
public async Task <IActionResult> PutWorkoutDay(int id, WorkoutDay workoutDay)
{
if (id != workoutDay.Id)
{
return(BadRequest());
}
try
{
_unitOfWork.WorkoutDayRepository.Update(workoutDay);
await _unitOfWork.Save();
}
catch (Exception ex)
{
if (!await WorkoutDayExists(id))
{
return(NotFound(ex));
}
else
{
throw;
}
}
return(NoContent());
}
public ActionResult <int> CreateWorkoutDay(WorkoutDay workoutDay)
{
System.Console.WriteLine("Hello from Mac");
var savedWorkoutDay = _context.WorkoutDays.Add(workoutDay);
var stations = _context.Stations;
var workout = new Workout()
{
WorkoutDayFK = savedWorkoutDay.Entity.Id,
StationSets = new List <StationSet>()
{
new StationSet {
StationFK = 1,
Sets = new List <Set>()
{
new Set {
Reps = 10,
Weight = 80
}
}
}
}
};
_context.Workouts.Add(workout);
var result = _context.SaveChanges();
return(1);
}
public async Task <IActionResult> Edit(int id, [Bind("Id,DayOfWeek,MuscleGroup, PlanId")] WorkoutDay workoutDay)
{
if (id != workoutDay.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_unitOfWork.WorkoutDayRepository.Update(workoutDay);
await _unitOfWork.Save();
}
catch (EF.DbUpdateConcurrencyException)
{
if (!await WorkoutDayExists(workoutDay.Id))
{
return(NotFound());
}
throw;
}
return(RedirectToAction(nameof(Index)));
}
return(View(workoutDay));
}
public async Task <IActionResult> Edit(int id, [Bind("ID,WorkoutID,ExerciseID,NumberSets,GoalReps,GoalWeight,GoalWeightPercentage,EstimatedOneRepMax,GoalRPE,ProgressionPercentage,LastCompletedID")] WorkoutDay workoutDay)
{
if (id != workoutDay.ID)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(workoutDay);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!WorkoutDayExists(workoutDay.ID))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(workoutDay));
}
private ICollection <WorkoutDay> SetUpInitialWorkoutDays(string workoutRoutineId, DayOfWeek[] days, string[] exercises)
{
var workoutDays = new List <WorkoutDay>();
if (days == null || exercises == null)
{
return(workoutDays);
}
foreach (var day in days)
{
var workoutDay = new WorkoutDay
{
Day = day,
WorkoutRoutineId = workoutRoutineId,
};
var dayIntValue = (int)day;
var exercisesForWorkoutDayCollection = GetExercisesForCurrentDay(dayIntValue, exercises, workoutDay);
workoutDay.ExerciseWorkoutDay = exercisesForWorkoutDayCollection;
workoutDays.Add(workoutDay);
}
return(workoutDays);
}
public async Task <ActionResult <WorkoutDay> > PostWorkoutDay(WorkoutDay workoutDay)
{
await _unitOfWork.WorkoutDayRepository.Create(workoutDay);
await _unitOfWork.Save();
return(CreatedAtAction("GetWorkoutDay", new { id = workoutDay.Id }, workoutDay));
}
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 async Task <IActionResult> Create([Bind("ID,WorkoutID,ExerciseID,NumberSets,GoalReps,GoalWeight,GoalWeightPercentage,EstimatedOneRepMax,GoalRPE,ProgressionPercentage,LastCompletedID")] WorkoutDay workoutDay)
{
if (ModelState.IsValid)
{
_context.Add(workoutDay);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(workoutDay));
}
public async Task CreateWorkoutDayAsync(string workoutId, WeekDay weekDay)
{
var workoutDay = new WorkoutDay
{
WeekDay = weekDay,
WorkoutId = workoutId,
};
await this.workoutDaysRepository.AddAsync(workoutDay);
await this.workoutDaysRepository.SaveChangesAsync();
}
public async Task <IActionResult> Create([Bind("Id,DayOfWeek,MuscleGroup,PlanId")] WorkoutDay workoutDay)
{
if (ModelState.IsValid)
{
await _unitOfWork.WorkoutDayRepository.Create(workoutDay);
await _unitOfWork.Save();
return(RedirectToAction(nameof(Index)));
}
return(View(workoutDay));
}
public IHttpActionResult PostWorkout(WorkoutPostDto workout)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var insertItem = AutoMapper.Mapper.Map <Workout>(workout);
// muscleGroups entities assigned to workout by ids from dto information
var muscleGroups = db.MuscleGroups.ToList();
var workoutMuscleGroups = new List <MuscleGroup>();
foreach (var i in workout.MuscleGroups)
{
workoutMuscleGroups.Add(muscleGroups.Single(a => a.MuscleGroupId == i.MuscleGroupId));
}
insertItem.MuscleGroups = workoutMuscleGroups;
// ---------------------------
// exercises entities assigned to workout by ids from dto information
var exercises = db.Exercises.ToList();
var workoutExercises = new List <Exercise>();
foreach (var i in workout.Exercises)
{
workoutExercises.Add(exercises.Single(a => a.ExerciseId == i.ExerciseId));
}
insertItem.Exercises = workoutExercises;
// ---------------------------
// workoutDays entities created to workout from dto information
var workoutWorkoutDays = new List <WorkoutDay>();
foreach (var i in workout.WorkoutDays)
{
var workoutDays = new WorkoutDay();
workoutDays.WorkoutDayMonthWeek = i.WorkoutDayMonthWeek;
workoutDays.WorkoutDayWeekDay = i.WorkoutDayWeekDay;
workoutWorkoutDays.Add(workoutDays);
}
insertItem.WorkoutDays = workoutWorkoutDays;
// ---------------------------
// Inserting new workout with all information
db.Workouts.Add(insertItem);
db.SaveChanges();
var workoutDto = AutoMapper.Mapper.Map <WorkoutGetDto>(insertItem);
return(CreatedAtRoute("DefaultApi", new { id = workoutDto.WorkoutId }, workoutDto));
}
public WorkoutRoutine Generate(GainzDBContext dbContext)
{
WorkoutRoutine workoutRoutine = new WorkoutRoutine
{
WorkoutDays = new List <WorkoutDay>()
};
int frequency = (int)this.GeneratorSettings.Frequency;
RepScheme repScheme = this.GeneratorSettings.RepScheme;
workoutRoutine.Frequency = frequency;
workoutRoutine.Volume = this.GeneratorSettings.Volume;
workoutRoutine.RepScheme = repScheme;
workoutRoutine.ExerciseTypes = this.GeneratorSettings.ExerciseTypes.Select(x => EnumLabelLookup.ExerciseTypeLabels[x]).ToList();
workoutRoutine.Name = NameGenerator.NameGenerator.getName();
var splits = dbContext.Splits
.Include(x => x.SplitDays)
.ThenInclude(x => x.Day)
.ThenInclude(x => x.DaysMuscles)
.ThenInclude(x => x.Muscle)
.Where(x => x.Frequency == frequency).ToList();
if (splits.Count() == 0)
{
throw new Exception("No workout split available with selected Frequency");
}
Random r = new Random();
Split split = splits.ElementAt(r.Next(splits.Count()));
workoutRoutine.SplitName = split.Name;
List <SplitDay> splitDays = split.SplitDays.OrderBy(x => x.ID).ToList();
Dictionary <string, WorkoutDay> likeDays = new Dictionary <string, WorkoutDay>();
foreach (SplitDay splitDay in splitDays)
{
WorkoutDayGenerator workoutDayGenerator = new WorkoutDayGenerator(repScheme, splitDay, GeneratorSettings);
WorkoutDay workoutDay = likeDays.ContainsKey(splitDay.Day.Name) ?
likeDays[splitDay.Day.Name] : workoutDayGenerator.Generate(dbContext);
likeDays[splitDay.Day.Name] = workoutDay;
workoutRoutine.WorkoutDays.Add(workoutDay);
}
return(workoutRoutine);
}
public WorkoutDay GetWorkoutLayout(WorkoutDay workout, double mainliftTrainingMax)
{
foreach (var exercise in workout.WorkoutExercises)
{
foreach (var set in exercise.ExerciseSets)
{
if (set.UseTM)
{
set.Weight = GetSetWeight(set.TmPercent.Value, mainliftTrainingMax);
}
}
}
return(workout);
}
// GET: Repeats/CreateFromExercise/328
public IActionResult CreateFromPlan(int?Id)
{
if (Id == default(int))
{
throw new ArgumentNullException("plan id is not set");
}
var repeat = new WorkoutDay()
{
PlanId = Id.Value
};
return(View(nameof(Create), repeat));
}
public WorkoutDay Generate(GainzDBContext dbContext)
{
WorkoutDay workoutDay = new WorkoutDay(SplitDay.Day.IsRest, SplitDay.Day.Name)
{
Workouts = new List <Workout>()
};
List <Exercise> usedExercises = new List <Exercise>();
//Rest Day
if (VolumeMuscleMap.Count == 0)
{
return(workoutDay);
}
WorkoutGenerator workoutGenerator = new WorkoutGenerator(RepScheme, VolumeMuscleMap.First().Key, GeneratorSettings);
while (VolumeMuscleMap.Count > 0)
{
var muscle = VolumeMuscleMap.First().Key;
var count = VolumeMuscleMap[muscle] / RepScheme.TotalReps();
workoutGenerator.ExerciseCount = count == 0 ? 1 : count;
workoutGenerator.MuscleToWork = muscle;
var workouts = workoutGenerator.Generate(dbContext);
foreach (var workout in workouts)
{
foreach (var workedMuscle in workout.Exercise.ExerciseMuscles.Select(x => x.Muscle))
{
if (VolumeMuscleMap.ContainsKey(workedMuscle))
{
VolumeMuscleMap[workedMuscle] -= workout.TotalReps();
if (VolumeMuscleMap[workedMuscle] <= 0)
{
VolumeMuscleMap.Remove(workedMuscle);
}
}
}
}
workoutDay.Workouts.AddRange(workouts);
}
return(workoutDay);
}
private void AddExercisesToWorkoutDay(ApplicationDbContext dbContext, WorkoutDay workoutday)
{
var exercises = dbContext.Exercises.OrderBy(e => Guid.NewGuid()).Take(5).ToList();
for (int i = 0; i < 5; i++)
{
var workoutDayExercise = new WorkoutDayExercise
{
WorkoutDay = workoutday,
ExerciseId = exercises[i].Id,
Position = i + 1,
};
dbContext.WorkoutDaysExercises.Add(workoutDayExercise);
}
}
public async Task AddWorkoutPlantToClient(WorkoutPlanInputModel input)
{
var client = await this.db.Users.FirstOrDefaultAsync(u => u.Id == input.ClientId);
if (client == null)
{
throw new ArgumentException("Невалиден клиент.");
}
var workoutPlan = new WorkoutPlan()
{
User = client,
UserId = client.Id,
};
var workoutDays = new List <WorkoutDay>();
foreach (var day in input.WorkoutDays.Where(d => d.Exercises != null).ToList())
{
var workoutDay = new WorkoutDay()
{
WorkDay = day.WorkDay,
WorkoutPlan = workoutPlan,
WorkoutPlanId = workoutPlan.WorkoutPlanId,
};
foreach (var inputExercise in day.Exercises)
{
var exercise = new Exercise()
{
MuscleGroup = inputExercise.MuscleGroup,
Name = inputExercise.Name,
RepsOrTime = inputExercise.RepsOrTime,
WorkoutDay = workoutDay,
WorkoutDayId = workoutDay.WorkoutDayId,
};
workoutDay.Exercises.Add(exercise);
}
workoutDays.Add(workoutDay);
}
workoutPlan.WorkoutDays = workoutDays;
await this.db.WorkoutPlans.AddAsync(workoutPlan);
await this.db.SaveChangesAsync();
}
private void AddWorkoutDaysToWorkout(ApplicationDbContext dbContext, Workout workout)
{
for (int i = 1; i <= 5; i += 2)
{
var workoutDay = new WorkoutDay
{
WeekDay = (WeekDay)i, // "i" will correspond to "Monday"(1), "Wednessday"(3) and "Friday"(5) from "WeekDay" enum!
Workout = workout,
};
this.AddExercisesToWorkoutDay(dbContext, workoutDay);
dbContext.WorkoutDays.Add(workoutDay);
workout.WorkoutDays.Add(workoutDay);
}
}
async Task ExecuteLoadItemsCommand()
{
IsBusy = true;
try
{
Program = (await ProgramDataStore.GetItemsAsync(true)).First();
WorkoutDay.Clear();
WorkoutDay.AddRange(Program.WorkoutDays);
OnPropertyChanged(nameof(Program));
}
catch (Exception ex)
{
Debug.WriteLine(ex);
}
finally
{
IsBusy = false;
}
}
public MockWorkoutDataStore()
{
var exercises = new List <Exercise>
{
new Exercise("Squat", new OneRM(75), 3, 4, 100, 3),
new Exercise("Stiff Leg Deadlift", new RPE(7), 3, 10, 60, 2),
new Exercise("Leg Press", new RPE(8), 2, 20, 75, 2),
new Exercise("Calf Raise", new RPE(8), 5, 12, 50, 2),
};
var lowerDay1 = new WorkoutDay("Lower #1", 1, exercises, DateTimeOffset.Now);
workoutProgram = new WorkoutProgram()
{
Title = "Upper/Lower Strenght and Size",
WorkoutDays = new List <WorkoutDay>
{
lowerDay1, lowerDay1, lowerDay1, lowerDay1
},
};
}
public void SavePlan()
{
if (string.IsNullOrWhiteSpace(WorkoutPlanItem.WorkoutPlan.Title) ||
WorkoutPlanExpireDate == null)
{
return;
}
WorkoutPlanItem.WorkoutPlan.AddedDate = DateTime.Now;
WorkoutPlanItem.WorkoutPlan.ExpireDate = WorkoutPlanExpireDate;
using var db = new AppDbContext();
db.WorkoutPlans.Add(WorkoutPlanItem.WorkoutPlan);
db.SaveChanges();
var dayNumber = 1;
foreach (var date in DateRange(DateTime.Now, WorkoutPlanExpireDate))
{
var workoutDay = new WorkoutDay()
{
WorkoutPlanId = WorkoutPlanItem.WorkoutPlan.Id,
Date = date,
DayNumber = dayNumber,
IsCompleted = false
};
db.WorkoutDays.Add(workoutDay);
db.SaveChanges();
WorkoutPlanItem.WorkoutDayItems.Add(new WorkoutDayItem
{
WorkoutDay = workoutDay
});
dayNumber += 1;
}
}
protected override void Seed(sport_workouts_web_api.Models.ApplicationDbContext context)
{
if (!context.MuscleGroups.Any())
{
string image_url = "assets/images/";
// Main muscle groups
MuscleGroup muscleGroup1 = new MuscleGroup()
{
MuscleGroupName = "Nugara"
};
MuscleGroup muscleGroup2 = new MuscleGroup()
{
MuscleGroupName = "Pilvo presas"
};
MuscleGroup muscleGroup3 = new MuscleGroup()
{
MuscleGroupName = "Rankos"
};
MuscleGroup muscleGroup4 = new MuscleGroup()
{
MuscleGroupName = "Kojos"
};
MuscleGroup muscleGroup5 = new MuscleGroup()
{
MuscleGroupName = "Krūtinė"
};
// Exercises for chest
Exercise Exercise1 = new Exercise()
{
ExerciseName = "Štangos spaudimas", ExerciseImageFirst = image_url + "stangos_spaudimas.gif", ExerciseImageSecond = image_url + "stangos_spaudimas.gif"
};
Exercise Exercise2 = new Exercise()
{
ExerciseName = "Krūtinės plėšimas", ExerciseImageFirst = image_url + "plesimas_tiesiai.gif", ExerciseImageSecond = image_url + "plesimas_tiesiai.gif"
};
Exercise Exercise3 = new Exercise()
{
ExerciseName = "Puloveris", ExerciseImageFirst = image_url + "DumbbellPullover.gif", ExerciseImageSecond = image_url + "DumbbellPullover.gif"
};
// Exercises for back
Exercise Exercise4 = new Exercise()
{
ExerciseName = "Prisitraukimai", ExerciseImageFirst = image_url + "prisitrukimai_prie_kaklo.gif", ExerciseImageSecond = image_url + "prisitrukimai_prie_kaklo.gif"
};
Exercise Exercise5 = new Exercise()
{
ExerciseName = "Lyno trauka prie pilvo", ExerciseImageFirst = image_url + "lyno_trauka_prie_pilvo.gif", ExerciseImageSecond = image_url + "lyno_trauka_prie_pilvo.gif"
};
Exercise Exercise6 = new Exercise()
{
ExerciseName = "Nugaros tiesimas", ExerciseImageFirst = image_url + "atilenkimai_nugaros_apaciai.gif", ExerciseImageSecond = image_url + "atilenkimai_nugaros_apaciai.gif"
};
// Exercises for legs
Exercise Exercise7 = new Exercise()
{
ExerciseName = "Pritūpimai", ExerciseImageFirst = image_url + "pritupimai.gif", ExerciseImageSecond = image_url + "pritupimai.gif"
};
Exercise Exercise8 = new Exercise()
{
ExerciseName = "Įtūpstai su hanteliais", ExerciseImageFirst = image_url + "itupstai_su_hanteliais.gif", ExerciseImageSecond = image_url + "itupstai_su_hanteliais.gif"
};
// Exercises for hands
Exercise Exercise9 = new Exercise()
{
ExerciseName = "Stovint su hanteliais", ExerciseImageFirst = image_url + "stovint_su_hanteliais.gif", ExerciseImageSecond = image_url + "stovint_su_hanteliais.gif"
};
Exercise Exercise10 = new Exercise()
{
ExerciseName = "Štangos spaudimas siaurai", ExerciseImageFirst = image_url + "stangos_spaudimas_siaurai.gif", ExerciseImageSecond = image_url + "stangos_spaudimas_siaurai.gif"
};
// Exercises for abs
Exercise Exercise11 = new Exercise()
{
ExerciseName = "Atsilenkimai", ExerciseImageFirst = image_url + "atsilenkimai.gif", ExerciseImageSecond = image_url + "atsilenkimai.gif"
};
Exercise Exercise12 = new Exercise()
{
ExerciseName = "Atsilenkimai šonu", ExerciseImageFirst = image_url + "atsilenkimia_sonu.gif", ExerciseImageSecond = image_url + "atsilenkimia_sonu.gif"
};
WorkoutDay WorkoutDay1 = new WorkoutDay()
{
WorkoutDayMonthWeek = 1, WorkoutDayWeekDay = 1
};
WorkoutDay WorkoutDay2 = new WorkoutDay()
{
WorkoutDayMonthWeek = 2, WorkoutDayWeekDay = 3
};
WorkoutDay WorkoutDay3 = new WorkoutDay()
{
WorkoutDayMonthWeek = 3, WorkoutDayWeekDay = 2
};
WorkoutDay WorkoutDay4 = new WorkoutDay()
{
WorkoutDayMonthWeek = 4, WorkoutDayWeekDay = 6
};
// Workouts
Workout Workout1 = new Workout()
{
WorkoutName = "Kojų ir pilvo preso treniruotė"
};
Workout Workout2 = new Workout()
{
WorkoutName = "Krūtinės ir rankų treniruotė"
};
Workout Workout3 = new Workout()
{
WorkoutName = "Nugaros treniruotė"
};
// Legs and abs workout muscle groups
Workout1.MuscleGroups.Add(muscleGroup2);
Workout1.MuscleGroups.Add(muscleGroup4);
muscleGroup2.Workouts.Add(Workout1);
muscleGroup4.Workouts.Add(Workout1);
// Legs and abs workout exercises
Workout1.Exercises.Add(Exercise7);
Workout1.Exercises.Add(Exercise8);
Workout1.Exercises.Add(Exercise11);
Workout1.Exercises.Add(Exercise12);
Exercise7.Workouts.Add(Workout1);
Exercise8.Workouts.Add(Workout1);
Exercise11.Workouts.Add(Workout1);
Exercise12.Workouts.Add(Workout1);
// Chest and hands workout muscle groups
Workout2.MuscleGroups.Add(muscleGroup3);
Workout2.MuscleGroups.Add(muscleGroup5);
muscleGroup3.Workouts.Add(Workout2);
muscleGroup5.Workouts.Add(Workout2);
// Chest and hands workout exercises
Workout2.Exercises.Add(Exercise1);
Workout2.Exercises.Add(Exercise2);
Workout2.Exercises.Add(Exercise3);
Workout2.Exercises.Add(Exercise9);
Workout2.Exercises.Add(Exercise10);
Exercise1.Workouts.Add(Workout2);
Exercise2.Workouts.Add(Workout2);
Exercise3.Workouts.Add(Workout2);
Exercise9.Workouts.Add(Workout2);
Exercise10.Workouts.Add(Workout2);
// Back workout muscle groups
Workout3.MuscleGroups.Add(muscleGroup1);
muscleGroup1.Workouts.Add(Workout3);
// Legs and abs workout exercises
Workout3.Exercises.Add(Exercise4);
Workout3.Exercises.Add(Exercise5);
Workout3.Exercises.Add(Exercise6);
Exercise4.Workouts.Add(Workout3);
Exercise5.Workouts.Add(Workout3);
Exercise6.Workouts.Add(Workout3);
// Leg exercises with leg muscle group
Exercise7.MuscleGroups.Add(muscleGroup4);
Exercise8.MuscleGroups.Add(muscleGroup4);
muscleGroup4.Exercises.Add(Exercise7);
muscleGroup4.Exercises.Add(Exercise8);
// Chest exercises with chest muscle group
Exercise1.MuscleGroups.Add(muscleGroup5);
Exercise2.MuscleGroups.Add(muscleGroup5);
Exercise3.MuscleGroups.Add(muscleGroup5);
muscleGroup5.Exercises.Add(Exercise1);
muscleGroup5.Exercises.Add(Exercise2);
muscleGroup5.Exercises.Add(Exercise3);
// Back exercises with back muscle group
Exercise4.MuscleGroups.Add(muscleGroup1);
Exercise5.MuscleGroups.Add(muscleGroup1);
Exercise6.MuscleGroups.Add(muscleGroup1);
muscleGroup1.Exercises.Add(Exercise4);
muscleGroup1.Exercises.Add(Exercise5);
muscleGroup1.Exercises.Add(Exercise6);
// Hands exercises with hands muscle group
Exercise9.MuscleGroups.Add(muscleGroup3);
Exercise10.MuscleGroups.Add(muscleGroup3);
muscleGroup3.Exercises.Add(Exercise9);
muscleGroup3.Exercises.Add(Exercise10);
// Abs exercises with abs muscle group
Exercise11.MuscleGroups.Add(muscleGroup2);
Exercise12.MuscleGroups.Add(muscleGroup2);
muscleGroup2.Exercises.Add(Exercise11);
muscleGroup2.Exercises.Add(Exercise12);
// Workouts with dates
Workout1.WorkoutDays.Add(WorkoutDay1);
Workout1.WorkoutDays.Add(WorkoutDay2);
Workout2.WorkoutDays.Add(WorkoutDay3);
Workout3.WorkoutDays.Add(WorkoutDay4);
// Add all data to database (Workouts now includes all other data)
context.Workouts.Add(Workout1);
context.Workouts.Add(Workout2);
context.Workouts.Add(Workout3);
}
}
public IHttpActionResult PutWorkout(int id, WorkoutUpdateDto workout)
{
/* if (!ModelState.IsValid)
* {
* return BadRequest(ModelState);
* }*/
if (id != workout.WorkoutId)
{
return(BadRequest());
}
var work = db.Workouts.Find(id);
AutoMapper.Mapper.Map(workout, work);
// Making list of musclegroups ids got from dto
var workoutMuscleGroupsIdList = new List <int>();
foreach (var i in workout.MuscleGroups)
{
workoutMuscleGroupsIdList.Add(i.MuscleGroupId);
}
// Checking if musclegroup existed in current workout, if not, remove it
foreach (var i in work.MuscleGroups.ToList())
{
if (!workoutMuscleGroupsIdList.Contains(i.MuscleGroupId))
{
work.MuscleGroups.Remove(i);
}
}
// Cheking if muscle group exists in database and adds it to workout if it does
foreach (var i in workout.MuscleGroups)
{
if (!work.MuscleGroups.Any(r => r.MuscleGroupId == i.MuscleGroupId))
{
var addMuscleGroup = db.MuscleGroups.Find(i.MuscleGroupId);
work.MuscleGroups.Add(addMuscleGroup);
}
}
// Making list of exercises ids got from dto
var workoutExerciseIdList = new List <int>();
foreach (var i in workout.Exercises)
{
workoutExerciseIdList.Add(i.ExerciseId);
}
// Checking if exercise existed in current workout, if not, remove it
foreach (var i in work.Exercises.ToList())
{
if (!workoutExerciseIdList.Contains(i.ExerciseId))
{
work.Exercises.Remove(i);
}
}
// Cheking if muscle group exists in database and adds it to workout if it does
foreach (var i in workout.Exercises)
{
if (!work.Exercises.Any(r => r.ExerciseId == i.ExerciseId))
{
var addExercise = db.Exercises.Find(i.ExerciseId);
work.Exercises.Add(addExercise);
}
}
// Making list of workoutDays ids got from dto
var workoutWorkoutDaysIdList = new List <int>();
foreach (var i in workout.WorkoutDays)
{
workoutWorkoutDaysIdList.Add(i.WorkoutDayId);
}
// Checking if workoutDay existed in current workout, if not, remove it
foreach (var i in work.WorkoutDays.ToList())
{
if (!workoutWorkoutDaysIdList.Contains(i.WorkoutDayId))
{
work.WorkoutDays.Remove(i);
}
}
// Cheking if muscle group exists in database and adds it to workout if it does
foreach (var i in workout.WorkoutDays)
{
// if workday is new, than create new and add to workout
if (i.WorkoutDayId == 0)
{
var workoutWorkoutDaysNew = new List <WorkoutDay>();
foreach (var j in workout.WorkoutDays)
{
var workoutDays = new WorkoutDay();
workoutDays.WorkoutDayMonthWeek = j.WorkoutDayMonthWeek;
workoutDays.WorkoutDayWeekDay = j.WorkoutDayWeekDay;
workoutWorkoutDaysNew.Add(workoutDays);
}
work.WorkoutDays = workoutWorkoutDaysNew;
}
// if workday already existed, find it and change its values
else
{
var workday = db.WorkoutDays.Find(i.WorkoutDayId);
workday.WorkoutDayMonthWeek = i.WorkoutDayMonthWeek;
workday.WorkoutDayWeekDay = i.WorkoutDayWeekDay;
}
}
try
{
db.SaveChanges();
}
catch (DbUpdateConcurrencyException)
{
if (!WorkoutExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
var updatedWorkout = db.Workouts.Find(id);
WorkoutGetDto result = AutoMapper.Mapper.Map <WorkoutGetDto>(updatedWorkout);
return(Ok(result));
}
private List <ExerciseWorkoutDay> GetExercisesForCurrentDay(int dayIntValue, string[] exercises, WorkoutDay workoutDay)
{
var exercisesForWorkoutDayCollection = new List <ExerciseWorkoutDay>();
//Each exercise caries its day in the name (ex. Pull up-1)
if (exercises.Any(x => x.Contains(dayIntValue.ToString())))
{
foreach (var exercise in exercises.Where(x => x.Contains(dayIntValue.ToString())))
{
var parsedExerciseName = exercise.Split('-').First();
var exerciseEntity = _exercisesService.GetSingleExerciseByName(parsedExerciseName);
exercisesForWorkoutDayCollection.Add(new ExerciseWorkoutDay
{
Exercise = exerciseEntity,
WorkoutDay = workoutDay
});
}
}
return(exercisesForWorkoutDayCollection);
}
