public virtual TrainingCycle GenerateNewTrainingCycle(WorkoutRoutine parentRoutine)
{
NewRoutineId = parentRoutine.Id;
var newCycleNumber = parentRoutine.TrainingCycles.Max(cycle => cycle.CycleNumber) + 1;
return(base.GenerateNewTrainingCycle(parentRoutine.Id, newCycleNumber));
}
public IActionResult Create(CreateWorkoutViewModel viewModel)
{
if (!ModelState.IsValid)
{
return(this.View(viewModel));
}
var identityUserId = _userService.GetIdentityIdByUsername(this.User.Identity.Name);
var mainUser = _userService.GetMainUserByIdentityId(identityUserId);
var workout = new WorkoutRoutine
{
IsPublic = viewModel.IsPublic,
Name = viewModel.Name,
CreatorId = mainUser.Id,
};
var workoutDays = SetUpInitialWorkoutDays(workout.Id, viewModel.Days, viewModel.ExerciseName);
workout.WorkoutDays = workoutDays;
_repository.Add <WorkoutRoutine>(workout);
return(Redirect("/Workout/Index"));
}
public async Task <bool> UpdateRoutine(WorkoutRoutine routine)
{
var routineEntity = await _context.WorkoutRoutines
.Include(w => w.ExerciseRoutineEntries)
.Include(w => w.RoutineProgramEntries)
.SingleOrDefaultAsync(w => w.ID == routine.ID);
if (routineEntity == null || routineEntity.WTUserID != routine.WTUserID)
{
return(false);
}
routine.ExerciseRoutineEntries.ToList().ForEach(item => item.WorkoutRoutineID = routineEntity.ID);
var updateExercisesResult = await UpdateExercisesForRoutine(routineEntity, routine.ExerciseRoutineEntries.ToList());
if (updateExercisesResult == false)
{
return(false);
}
//routine.RoutineProgramEntries.ToList().ForEach(item => item.WorkoutRoutineID = routineEntity.ID);
//var updateProgramsResult = await UpdateProgramsForRoutine(routineEntity, routine.RoutineProgramEntries.ToList());
//if (updateProgramsResult == false)
// return false;
routineEntity.Name = routine.Name;
routineEntity.PlannedDates = routine.PlannedDates;
routineEntity.Description = routine.Description;
await _context.SaveChangesAsync();
return(true);
}
public IActionResult PurchaseWorkoutRoutine(long id, [FromBody] long workoutRoutineId)
{
try
{
WorkoutRoutine workoutRoutine = workoutRoutineRepository.GetById(workoutRoutineId);
if (workoutRoutine == null)
{
return(BadRequest("Invalid workout routine Id: " + workoutRoutineId));
}
Athlete athlete = athleteRepository.GetById(id);
if (athlete == null)
{
return(BadRequest("Invalid athlete Id: " + id));
}
if (athlete.PurchasedWorkoutRoutine.Any(x => x.WorkoutRoutineId == workoutRoutine.Id && (x.ExpirationDate == null || x.ExpirationDate.Value >= DateTime.UtcNow)))
{
return(BadRequest("The workout routine is already purchased: " + workoutRoutine.Name));
}
athleteService.PurchaseWorkoutRoutine(athlete, workoutRoutine);
athleteRepository.SaveChanges();
return(Ok());
}
catch (Exception e)
{
return(StatusCode(500, new { error = e.Message }));
}
}
public static List <WorkoutRoutine> GetWorkoutsByDayAndUser(int intDayID, int intUserID)
{
List <WorkoutRoutine> retval = new List <WorkoutRoutine>();
// create and open connection
NpgsqlConnection conn = DatabaseConnection.GetConnection();
conn.Open();
// define a query
string query = "SELECT wr.\"intWorkoutRoutineID\"," +
" wr.\"intTotalMinutes\"," +
" wr.\"intTotalCalsBurned\"," +
" wr.\"intUserID\"" +
" FROM \"workoutRoutine\" wr, \"day\" d, \"dayExercise\" de" +
" WHERE wr.\"intUserID\" = " + intUserID +
" AND d.\"intDayID\" = " + intDayID +
" AND de.\"intDayID\" = d.\"intDayID\"" +
" AND wr.\"intWorkoutRoutineID\" = de.\"intWorkoutRoutineID\"";
NpgsqlCommand cmd = new NpgsqlCommand(query, conn);
// execute query
NpgsqlDataReader dr = cmd.ExecuteReader();
// read all rows and output the first column in each row
while (dr.Read())
{
WorkoutRoutine workout = GetWorkoutRoutineFromDR(dr);
retval.Add(workout);
}
conn.Close();
return(retval);
}
public ActionResult DeleteWorkout(WorkoutRoutine workout, int intDayID, int intUserID)
{
WorkoutHomeVM model = new WorkoutHomeVM()
{
LstWorkoutRoutines = WorkoutRoutineDAL.GetWorkoutsByDayAndUser(intDayID, intUserID).Where(w => w != workout)
};
return(View("WorkoutHome", model));
}
protected virtual TrainingCycle GetFirstTrainingCycleFromBaseRoutine(WorkoutRoutine baseRoutine)
{
if (baseRoutine.TrainingCycles.IsEmptyOrNull())
{
throw new ApplicationException(
"Routine generation failed: base routine provided in NewRoutineInfo has no cycles!"
);
}
return(baseRoutine.TrainingCycles !.First());
}
private static WorkoutRoutine GetWorkoutRoutineFromDR(NpgsqlDataReader dr)
{
int intWorkoutRoutineID = Convert.ToInt32(dr["intWorkoutRoutineID"]);
int intTotalMinutes = Convert.ToInt32(dr["intTotalMinutes"]);
int intTotalCalsBurned = Convert.ToInt32(dr["intTotalCalsBurned"]);
int intUserID = Convert.ToInt32(dr["intUserID"]);
List <ExerciseType> lstRoutine = ExerciseTypeDAL.GetExercisesByWorkout(intWorkoutRoutineID).ToList();
WorkoutRoutine workoutRoutine = WorkoutRoutine.of(intWorkoutRoutineID, intTotalMinutes, lstRoutine, intTotalCalsBurned);
return(workoutRoutine);
}
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 void DeleteWorkout()
{
// Act
var controller = new WorkoutController();
List <ExerciseType> lstExercises = new List <ExerciseType>();
WorkoutRoutine workout = WorkoutRoutine.of(10, lstExercises, 100);
// Arrange
var result = controller.DeleteWorkout(workout, 5, 5);
// Assert
Assert.IsNotNull(result);
}
public virtual WorkoutRoutine GenerateNewRoutine()
{
var routine = new WorkoutRoutine
{
Id = NewRoutineId,
RoutineTypeId = NewRoutineInfo.BaseRoutine.RoutineTypeId,
Name = NewRoutineInfo.BaseRoutine.Name,
Description = NewRoutineInfo.BaseRoutine.Description
};
routine.TrainingCycles = new List <TrainingCycle> {
GenerateNewTrainingCycle(routine.Id)
};
return(routine);
}
internal static bool AddWorkoutRoutine(int[] arrIntExerciseTypeIDs)
{
int intUserID = HomeController.USER_NUMBER;
int intDayID = HomeController.DAY_NUMBER;
// calculate total minutes and total calories burned
List <ExerciseType> exercises = new List <ExerciseType>();
ExerciseType tmpExercise;
foreach (int id in arrIntExerciseTypeIDs)
{
tmpExercise = ExerciseTypeDAL.GetExerciseTypeByID(id);
exercises.Add(tmpExercise);
}
int intTotalMinutes = 0;
int intTotalCalsBurned = 0;
foreach (ExerciseType ex in exercises)
{
intTotalMinutes += ex.intTime;
intTotalCalsBurned += ex.intCaloriesBurned;
}
WorkoutRoutine workoutRoutine = WorkoutRoutine.of(intTotalMinutes, exercises, intTotalCalsBurned);
// insert to workout table
// get the id of new workout
int intWorkoutRoutineID = InsertToWorkoutTable(workoutRoutine, intUserID);
bool success = false;
// insert each id in array to workoutExerciseType table
foreach (ExerciseType ex in exercises)
{
success = InsertToWorkoutExerciseTypeTable(intWorkoutRoutineID, ex.intExerciseTypeID);
}
// remove time from alloted exercise minutes
bool exMinsSuccess = RemoveTime(intTotalMinutes, intUserID, intDayID);
// add calories to users' calories for the day
bool calsSuccess = AddCals(workoutRoutine.intTotalCalsBurned, intUserID, intDayID);
// insert to day/exercise table
bool daySuccess = InsertToDayExerciseTable(intWorkoutRoutineID, intDayID);
return(success && exMinsSuccess && calsSuccess);
}
public void PurchaseWorkoutRoutine(Athlete athlete, WorkoutRoutine workoutRoutine)
{
DateTime?expirationDate = workoutRoutineService.GetExpirationDate(workoutRoutine.LicensingModel);
decimal price = CalculatePrice(athlete.Status, athlete.StatusExpirationDate, workoutRoutine.LicensingModel);
var purchasedWorkoutRoutine = new PurchasedWorkoutRoutine
{
WorkoutRoutineId = workoutRoutine.Id,
AthleteId = athlete.Id,
ExpirationDate = expirationDate,
Price = price
};
athlete.PurchasedWorkoutRoutine.Add(purchasedWorkoutRoutine);
athlete.MoneySpent += price;
}
public async Task <bool> AddRoutineForUser(int?userId, WorkoutRoutine routine)
{
var user = await GetUserByUserId(userId);
if (user == null)
{
return(false);
}
routine.ID = 0;
routine.WTUserID = userId;
routine.ExerciseRoutineEntries.ToList().ForEach(item => item.WorkoutRoutineID = routine.ID);
routine.RoutineProgramEntries.ToList().ForEach(item => item.WorkoutRoutineID = routine.ID);
if (string.IsNullOrEmpty(routine.ImagePath))
{
routine.ImagePath = "Images/monkasRoutine.jpg";
}
//check if the posted programIDs or exerciseIDs belong to the user
var allUserProgramsIds = await _context.WorkoutPrograms
.AsNoTracking()
.Where(item => item.WTUserID == userId)
.Select(item => item.ID)
.ToListAsync();
var allUserExercisesIDs = await _context.Exercises
.AsNoTracking()
.Where(item => item.WTUserID == userId)
.Select(item => item.ID)
.ToListAsync();
var programsCheck = routine.RoutineProgramEntries.All(item => allUserProgramsIds.Contains((int)item.WorkoutProgramID));
var exerciseCheck = routine.ExerciseRoutineEntries.All(item => allUserExercisesIDs.Contains((int)item.ExerciseID));
if (!programsCheck || !exerciseCheck)
{
return(false);
}
_context.WorkoutRoutines.Add(routine);
await _context.SaveChangesAsync();
return(true);
}
private async Task <bool> SaveRoutineImage(WorkoutRoutine routineEntity)
{
try
{
// get this environment's web root path (the path
// from which static content, like an image, is served)
var webRootPath = _hostingEnvironment.WebRootPath;
string folderName = "Images/Routines/" + routineEntity.WTUserID.ToString();
string fullFolderPath = $"{webRootPath}/{folderName}/";
// create path if not exists... write bytes and auto-close stream
FileInfo file = new FileInfo(fullFolderPath);
file.Directory.Create();
// create the filename
string imageName = routineEntity.ImagePath;
var imageExtension = imageName.Substring(imageName.LastIndexOf("."));
string fileName = "routine_" + routineEntity.ID + "_" + Guid.NewGuid() + imageExtension;
//delete previuos image
string[] fileList = Directory.GetFiles(fullFolderPath, $"*routine_{routineEntity.ID}*");
foreach (var fileToDelete in fileList)
{
System.IO.File.Delete(fileToDelete);
}
// the full file path
var filePath = Path.Combine($"{fullFolderPath}/{fileName}");
System.IO.File.WriteAllBytes(filePath, routineEntity.ImageBytes);
// fill out the filename
routineEntity.ImagePath = folderName + "/" + fileName;
await _repository.UpdateImageForRoutine(routineEntity.ID, routineEntity.ImagePath);
return(true);
}
catch (Exception ex)
{
_logger.LogError(500, ex, ex.Message);
return(false);
}
}
public ActionResult GetWorkoutRoutine(GeneratorSettings generatorSettings)
{
generatorSettings.Initialize();
var generator = new RoutineGeneration.RoutineGenerator(generatorSettings);
try
{
var routine = generator.Generate(_context);
return(new JsonResult(routine));
}
catch (Exception ex)
{
WorkoutRoutine wr = new WorkoutRoutine();
wr.failed = true;
wr.failureMessage = ex.Message;
return(new JsonResult(wr));
}
}
public async Task Write(Workout workout)
{
var history = Read(workout.RoutineId);
WorkoutRoutine routine = null;
if (history == null)
{
history = new WorkoutHistory(getKeyFromRoutine(workout.RoutineId));
}
else
{
routine = getMostRecentNotCompletedWorkout(history);
}
if (routine == null)
{
history.WorkoutRoutines.Add(new WorkoutRoutine());
}
routine.Workouts.Add(workout);
history.key = getKeyFromRoutine(workout.RoutineId);
history.WorkoutRoutinesJSON = JsonConvert.SerializeObject(history.WorkoutRoutines);
await SaveAsync(history, _config);
}
public async Task <bool> UpdateProgramsForRoutine(WorkoutRoutine routineEntity, List <RoutineProgramEntry> routinePrograms)
{
if (routineEntity == null)
{
return(false);
}
//remove programs that arent present
var programsToBeRemoved = routineEntity.RoutineProgramEntries.Where(item => !routinePrograms.Any(rp => rp.WorkoutProgramID == item.WorkoutProgramID)).ToList();
_context.RemoveRange(programsToBeRemoved);
//add new programs
var toBeAdded = routinePrograms.Where(item => !routineEntity.RoutineProgramEntries.Any(rp => rp.WorkoutProgramID == item.WorkoutProgramID)).ToList();
var allUserProgramsIds = await _context.WorkoutPrograms
.AsNoTracking()
.Where(item => item.WTUserID == routineEntity.WTUserID)
.Select(item => item.ID)
.ToListAsync();
//check if all programs to be added belong to this user
var programsCheck = toBeAdded.All(item => allUserProgramsIds.Contains((int)item.WorkoutProgramID));
if (programsCheck == false)
{
return(false);
}
toBeAdded.ForEach(item => routineEntity.RoutineProgramEntries.Add(item));
await _context.SaveChangesAsync();
return(true);
}
public static int InsertToWorkoutTable(WorkoutRoutine workout, int intUserID)
{
NpgsqlConnection conn = DatabaseConnection.GetConnection();
conn.Open();
// define a query
string query = "INSERT INTO \"workoutRoutine\"" +
" (\"intTotalMinutes\", \"intTotalCalsBurned\", \"intUserID\")" +
" VALUES" +
" (@intTotalMinutes, @intTotalCalsBurned, @intUserID)" +
" RETURNING \"intWorkoutRoutineID\"";
NpgsqlCommand cmd = new NpgsqlCommand(query, conn);
cmd.Parameters.AddWithValue("intTotalMinutes", workout.intTotalMinutes);
cmd.Parameters.AddWithValue("intTotalCalsBurned", workout.intTotalCalsBurned);
cmd.Parameters.AddWithValue("intUserID", intUserID);
int result = (int)cmd.ExecuteScalar();
conn.Close();
return(result);
}
public async Task <bool> UpdateExercisesForRoutine(WorkoutRoutine routineEntity, List <ExerciseRoutineEntry> routineExercises)
{
if (routineEntity == null)
{
return(false);
}
//remove exercises that arent present
var exercisesToBeRemoved = routineEntity.ExerciseRoutineEntries.Where(item => !routineExercises.Any(re => re.ExerciseID == item.ExerciseID)).ToList();
_context.RemoveRange(exercisesToBeRemoved);
//add new exercises
var toBeAdded = routineExercises.Where(item => !routineEntity.ExerciseRoutineEntries.Any(ex => ex.ExerciseID == item.ExerciseID)).ToList();
var allUserExercisesIDs = await _context.Exercises
.AsNoTracking()
.Where(item => item.WTUserID == routineEntity.WTUserID)
.Select(item => item.ID)
.ToListAsync();
//check if all exercises to be added belong to this user
var exercisesCheck = toBeAdded.All(item => allUserExercisesIDs.Contains((int)item.ExerciseID));
if (exercisesCheck == false)
{
return(false);
}
toBeAdded.ForEach(item => routineEntity.ExerciseRoutineEntries.Add(item));
await _context.SaveChangesAsync();
return(true);
}
public static void Initialize(WorkoutTrackingDBContext context)
{
context.Database.EnsureCreated();
if (context.Users.Any())
{
return; // DB has been seeded
}
var users = new WTUser[]
{
new WTUser {
FirstName = "Riste", LastName = "Poposki", RegisterDate = DateTime.Parse("2017-09-01"), Email = "*****@*****.**", Password = "******", Username = "******"
},
new WTUser {
FirstName = "Monkas", LastName = "MonkaGiga", RegisterDate = DateTime.Now, Email = "*****@*****.**", Password = "******", Username = "******"
},
};
context.Users.AddRange(users);
context.SaveChanges();
var exercises = new Exercise[]
{
new Exercise {
Name = "Riste Execise 1", WTUserID = 1, Category = Category.ARMS, Description = "Riste Execise Desc 1", IsEditable = true, ImagePath = "Images/monkas.jpg"
},
new Exercise {
Name = "Riste Execise 2", WTUserID = 1, Category = Category.CHEST, Description = "Riste Execise Desc 2", IsEditable = true, ImagePath = "Images/monkas.jpg"
},
new Exercise {
Name = "Monkas Execise 1", WTUserID = 2, Category = Category.LEGS, Description = "Monkas Execise Desc 1", IsEditable = true, ImagePath = "Images/monkas.jpg"
},
new Exercise {
Name = "Monkas Execise 2", WTUserID = 2, Category = Category.OTHER, Description = "Monkas Execise Desc 2", IsEditable = true, ImagePath = "Images/monkas.jpg"
}
};
context.Exercises.AddRange(exercises);
context.SaveChanges();
var routines = new WorkoutRoutine[]
{
new WorkoutRoutine {
Name = "Riste Workout 1", Description = "Riste Routine Desc 1", WTUserID = 1, ImagePath = "Images/monkasRoutine.jpg"
},
new WorkoutRoutine {
Name = "Riste Workout 2", Description = "Riste Routine Desc 2", WTUserID = 1, ImagePath = "Images/monkasRoutine.jpg"
},
new WorkoutRoutine {
Name = "Monkas Workout 1", Description = "Monkas Routine Desc 1", WTUserID = 2, ImagePath = "Images/monkasRoutine.jpg"
},
new WorkoutRoutine {
Name = "Monkas Workout 1", Description = "Monkas Routine Desc 2", WTUserID = 2, ImagePath = "Images/monkasRoutine.jpg"
}
};
context.WorkoutRoutines.AddRange(routines);
context.SaveChanges();
var programs = new WorkoutProgram[]
{
new WorkoutProgram {
Name = "Riste Program 1", Description = "Riste Program Desc 1", WTUserID = 1, ImagePath = "Images/monkasProgram.png"
},
new WorkoutProgram {
Name = "Riste Program 2", Description = "Riste Program Desc 2", WTUserID = 1, ImagePath = "Images/monkasProgram.png"
},
new WorkoutProgram {
Name = "Monkas Program 1", Description = "Monkas Program Desc 1", WTUserID = 2, ImagePath = "Images/monkasProgram.png"
},
new WorkoutProgram {
Name = "Monkas Program 1", Description = "Monkas Program Desc 2", WTUserID = 2, ImagePath = "Images/monkasProgram.png"
},
};
context.WorkoutPrograms.AddRange(programs);
context.SaveChanges();
var sessions = new WorkoutSession[]
{
new WorkoutSession {
Date = DateTime.Now, WTUserID = 1
},
new WorkoutSession {
Date = DateTime.Now.AddDays(1), WTUserID = 1
},
new WorkoutSession {
Date = DateTime.Now, WTUserID = 2
},
new WorkoutSession {
Date = DateTime.Now.AddDays(1), WTUserID = 2
},
};
context.WorkoutSessions.AddRange(sessions);
context.SaveChanges();
var bodyStats = new BodyStatistic[]
{
new BodyStatistic {
DateCreated = DateTime.Now, Year = DateTime.Now.Year, Month = DateTime.Now.Month, Week = DateTime.Now.GetWeekOfMonth(), WTUserID = 1
},
new BodyStatistic {
DateCreated = DateTime.Now.AddDays(7), Year = DateTime.Now.AddDays(7).Year,
Month = DateTime.Now.AddDays(7).Month, Week = DateTime.Now.AddDays(7).GetWeekOfMonth(), WTUserID = 1
},
new BodyStatistic {
DateCreated = DateTime.Now, Year = DateTime.Now.Year, Month = DateTime.Now.Month, Week = DateTime.Now.GetWeekOfMonth(), WTUserID = 2
},
new BodyStatistic {
DateCreated = DateTime.Now.AddDays(7), Year = DateTime.Now.AddDays(7).Year,
Month = DateTime.Now.AddDays(7).Month, Week = DateTime.Now.AddDays(7).GetWeekOfMonth(), WTUserID = 2
},
};
context.BodyStatistics.AddRange(bodyStats);
context.SaveChanges();
var bodyAttributeTemplate = new BodyAttributeTemplate[]
{
new BodyAttributeTemplate {
AttributeName = "Template Attr 1", AttributeValue = "OK1", WTUserID = 1, IsDeletable = true
},
new BodyAttributeTemplate {
AttributeName = "Template Attr 2", AttributeValue = "OK2", WTUserID = 1, IsDeletable = true
},
new BodyAttributeTemplate {
AttributeName = "Template Attr 3", AttributeValue = "NO1", WTUserID = 2, IsDeletable = true
},
new BodyAttributeTemplate {
AttributeName = "Template Attr 4", AttributeValue = "NO2", WTUserID = 2, IsDeletable = true
}
};
context.BodyAttributeTemplates.AddRange(bodyAttributeTemplate);
context.SaveChanges();
var exerciseAttribute1 = new ExerciseAttribute {
AttributeName = "Sets", AttributeValue = "value1", ExerciseID = 1, IsDeletable = false
};
var exerciseAttribute2 = new ExerciseAttribute {
AttributeName = "Repetitions", AttributeValue = "value2", ExerciseID = 2, IsDeletable = false
};
var exerciseAttribute3 = new ExerciseAttribute {
AttributeName = "Sets", AttributeValue = "value1", ExerciseID = 3, IsDeletable = false
};
var exerciseAttribute4 = new ExerciseAttribute {
AttributeName = "Repetitions", AttributeValue = "value2", ExerciseID = 4, IsDeletable = false
};
var exercise = context.Exercises.SingleOrDefault(e => e.ID == 1);
exercise.Attributes = new List <ExerciseAttribute>();
exercise.Attributes.Add(exerciseAttribute1);
exercise = context.Exercises.SingleOrDefault(e => e.ID == 2);
exercise.Attributes = new List <ExerciseAttribute>();
exercise.Attributes.Add(exerciseAttribute2);
exercise = context.Exercises.SingleOrDefault(e => e.ID == 3);
exercise.Attributes = new List <ExerciseAttribute>();
exercise.Attributes.Add(exerciseAttribute3);
exercise = context.Exercises.SingleOrDefault(e => e.ID == 4);
exercise.Attributes = new List <ExerciseAttribute>();
exercise.Attributes.Add(exerciseAttribute4);
context.SaveChanges();
var bodyStatAttribute1 = new BodyStatAttribute {
AttributeName = "Riste Height", AttributeValue = "173", BodyStatisticID = 1, IsDeletable = true
};
var bodyStatAttribute2 = new BodyStatAttribute {
AttributeName = "Riste Weight", AttributeValue = "71", BodyStatisticID = 2, IsDeletable = true
};
var bodyStatAttribute3 = new BodyStatAttribute {
AttributeName = "Monkas Height", AttributeValue = "195", BodyStatisticID = 3, IsDeletable = true
};
var bodyStatAttribute4 = new BodyStatAttribute {
AttributeName = "Monkas Weight", AttributeValue = "91", BodyStatisticID = 4, IsDeletable = true
};
var bodyStat = context.BodyStatistics.SingleOrDefault(e => e.ID == 1);
bodyStat.BodyStatAttributes = new List <BodyStatAttribute>();
bodyStat.BodyStatAttributes.Add(bodyStatAttribute1);
bodyStat = context.BodyStatistics.SingleOrDefault(e => e.ID == 2);
bodyStat.BodyStatAttributes = new List <BodyStatAttribute>();
bodyStat.BodyStatAttributes.Add(bodyStatAttribute2);
bodyStat = context.BodyStatistics.SingleOrDefault(e => e.ID == 3);
bodyStat.BodyStatAttributes = new List <BodyStatAttribute>();
bodyStat.BodyStatAttributes.Add(bodyStatAttribute3);
bodyStat = context.BodyStatistics.SingleOrDefault(e => e.ID == 4);
bodyStat.BodyStatAttributes = new List <BodyStatAttribute>();
bodyStat.BodyStatAttributes.Add(bodyStatAttribute4);
context.SaveChanges();
var progressImage1 = new ProgressImage {
DateCreated = DateTime.Now, Url = "url1", BodyStatisticID = 1
};
var progressImage2 = new ProgressImage {
DateCreated = DateTime.Now.AddDays(1), Url = "url2", BodyStatisticID = 2
};
var progressImage3 = new ProgressImage {
DateCreated = DateTime.Now.AddDays(2), Url = "url3", BodyStatisticID = 3
};
var progressImage4 = new ProgressImage {
DateCreated = DateTime.Now.AddDays(3), Url = "url4", BodyStatisticID = 4
};
bodyStat = context.BodyStatistics.SingleOrDefault(e => e.ID == 1);
bodyStat.ProgressImages = new List <ProgressImage>();
bodyStat.ProgressImages.Add(progressImage1);
bodyStat = context.BodyStatistics.SingleOrDefault(e => e.ID == 2);
bodyStat.ProgressImages = new List <ProgressImage>();
bodyStat.ProgressImages.Add(progressImage2);
bodyStat = context.BodyStatistics.SingleOrDefault(e => e.ID == 3);
bodyStat.ProgressImages = new List <ProgressImage>();
bodyStat.ProgressImages.Add(progressImage3);
bodyStat = context.BodyStatistics.SingleOrDefault(e => e.ID == 4);
bodyStat.ProgressImages = new List <ProgressImage>();
bodyStat.ProgressImages.Add(progressImage4);
context.SaveChanges();
var exerciseRoutineEntry1 = new ExerciseRoutineEntry {
ExerciseID = 1, WorkoutRoutineID = 1
};
var exerciseRoutineEntry2 = new ExerciseRoutineEntry {
ExerciseID = 2, WorkoutRoutineID = 1
};
var exerciseRoutineEntry3 = new ExerciseRoutineEntry {
ExerciseID = 1, WorkoutRoutineID = 2
};
var routine = context.WorkoutRoutines.SingleOrDefault(u => u.ID == 1);
routine.ExerciseRoutineEntries = new List <ExerciseRoutineEntry>();
routine.ExerciseRoutineEntries.Add(exerciseRoutineEntry1);
routine.ExerciseRoutineEntries.Add(exerciseRoutineEntry2);
routine = context.WorkoutRoutines.SingleOrDefault(u => u.ID == 2);
routine.ExerciseRoutineEntries = new List <ExerciseRoutineEntry>();
routine.ExerciseRoutineEntries.Add(exerciseRoutineEntry3);
var exerciseRoutineEntry4 = new ExerciseRoutineEntry {
ExerciseID = 3, WorkoutRoutineID = 3
};
var exerciseRoutineEntry5 = new ExerciseRoutineEntry {
ExerciseID = 4, WorkoutRoutineID = 3
};
var exerciseRoutineEntry6 = new ExerciseRoutineEntry {
ExerciseID = 3, WorkoutRoutineID = 4
};
routine = context.WorkoutRoutines.SingleOrDefault(u => u.ID == 3);
routine.ExerciseRoutineEntries = new List <ExerciseRoutineEntry>();
routine.ExerciseRoutineEntries.Add(exerciseRoutineEntry4);
routine.ExerciseRoutineEntries.Add(exerciseRoutineEntry5);
routine = context.WorkoutRoutines.SingleOrDefault(u => u.ID == 4);
routine.ExerciseRoutineEntries = new List <ExerciseRoutineEntry>();
routine.ExerciseRoutineEntries.Add(exerciseRoutineEntry6);
context.SaveChanges();
var routineProgramEntry1 = new RoutineProgramEntry {
WorkoutRoutineID = 1, WorkoutProgramID = 1, PlannedDates = "2018-05-26;2018-06-01"
};
var routineProgramEntry2 = new RoutineProgramEntry {
WorkoutRoutineID = 2, WorkoutProgramID = 1, PlannedDates = "2018-05-29"
};
var routineProgramEntry3 = new RoutineProgramEntry {
WorkoutRoutineID = 1, WorkoutProgramID = 2, PlannedDates = "2018-07-26;2018-07-27"
};
var program = context.WorkoutPrograms.SingleOrDefault(u => u.ID == 1);
program.RoutineProgramEntries = new List <RoutineProgramEntry>();
program.RoutineProgramEntries.Add(routineProgramEntry1);
program.RoutineProgramEntries.Add(routineProgramEntry2);
program = context.WorkoutPrograms.SingleOrDefault(u => u.ID == 2);
program.RoutineProgramEntries = new List <RoutineProgramEntry>();
program.RoutineProgramEntries.Add(routineProgramEntry3);
var routineProgramEntry4 = new RoutineProgramEntry {
WorkoutRoutineID = 3, WorkoutProgramID = 3, PlannedDates = "2018-01-26;2018-01-27"
};
var routineProgramEntry5 = new RoutineProgramEntry {
WorkoutRoutineID = 4, WorkoutProgramID = 3, PlannedDates = "2018-02-26"
};
var routineProgramEntry6 = new RoutineProgramEntry {
WorkoutRoutineID = 3, WorkoutProgramID = 4, PlannedDates = "2018-03-26;2018-03-27"
};
program = context.WorkoutPrograms.SingleOrDefault(u => u.ID == 3);
program.RoutineProgramEntries = new List <RoutineProgramEntry>();
program.RoutineProgramEntries.Add(routineProgramEntry4);
program.RoutineProgramEntries.Add(routineProgramEntry5);
program = context.WorkoutPrograms.SingleOrDefault(u => u.ID == 4);
program.RoutineProgramEntries = new List <RoutineProgramEntry>();
program.RoutineProgramEntries.Add(routineProgramEntry6);
context.SaveChanges();
var ConcreteExercisesList = exercises.ToList().Select(item => item.GetConcreteExerciseObject()).ToList();
for (int i = 0; i < ConcreteExercisesList.Count(); i++)
{
var item = ConcreteExercisesList[i];
item.WorkoutSessionID = i + 1;
context.ConcreteExercises.Add(item);
}
context.SaveChanges();
}
