//[ValidateAntiForgeryToken]
public ActionResult Create([FromForm] WorkoutVM workoutVM)
{
var workout = new Workout();
workout.DateCreated = DateTime.Now;
workout.CreatedBy = 1;
workout.WorkoutName = workoutVM.Workout.WorkoutName;
workout.WorkoutToExercise = workoutVM.AllExercises.Where(e => e.Selected).Select(x => new WorkoutToExercise {
Workout = workout, ExerciseId = x.ExerciseID, Order = x.Order, Active = true
}).ToList();
workoutVM.AllExercises = workoutVM.AllExercises.Where(e => e.Selected).ToList();
workout.WorkoutSet = GetWorkOutSets(workoutVM, workout);
try
{
if (ModelState.IsValid)
{
_context.Workout.Add(workout);
_context.SaveChanges();
return(RedirectToAction("Index"));
}
}
catch (Exception ex)
{
ModelState.AddModelError("", "Unable to save changes. Try again, and if the problem persists see your system administrator.");
}
return(View(workout));
}
public void EditWorkout(WorkoutVM workoutVM)
{
var workout = MapMVM.WorkoutToWorkoutVM(workoutVM);
_uow.WorkoutRepository.UpdateWorkout(workout);
_uow.Save();
}
public void AddWorkout(WorkoutVM workoutVM)
{
var workout = MapMVM.WorkoutToWorkoutVM(workoutVM);
_uow.WorkoutRepository.CreateWorkout(workout);
_uow.Save();
}
public List <WorkoutSet> GetWorkOutSets(WorkoutVM workoutVM, Workout workout)
{
List <WorkoutSet> workoutSets = new List <WorkoutSet>();
foreach (var exercise in workoutVM.AllExercises)
{
List <int> sets = exercise.SetsAndReps
.Split(new char[] { ' ', ',' })
.Where(x => !string.IsNullOrEmpty(x))
.Select(x => int.Parse(x))
.ToList();
for (int i = 0; i < sets.Count; i++)
{
WorkoutSet workoutSet = new WorkoutSet();
workoutSet.Reps = sets[i];
workoutSet.SetOrder = i + 1;
workoutSet.ExerciseId = exercise.ExerciseID;
workoutSet.DateCreated = DateTime.Now;
workoutSet.Workout = workout;
workoutSet.ExerciseId = exercise.ExerciseID;
workoutSet.Active = true;
workoutSets.Add(workoutSet);
}
}
return(workoutSets);
}
public ActionResult EditWorkout(WorkoutVM w)
{
IWorkoutRepo wrepo = WorkoutRepoFactory.Create();
IClientRepo repo = ClientRepoFactory.Create();
ITrainerRepo trepo = TrainerRepoFactory.Create();
if (ModelState.IsValid)
{
var workout = new Workout
{
WorkoutID = w.WorkoutID,
WorkoutName = w.WorkoutName,
WorkoutDescription = w.WorkoutDescription,
};
foreach (var trainerID in w.SelectedTrainerID)
{
workout.TrainerCreator.Add(trepo.GetTrainerById(trainerID));
}
foreach (var clientID in w.SelectedClientID)
{
workout.ClientsOnWorkout.Add(repo.GetClientById(clientID));
}
wrepo.EditWorkout(workout);
}
return(RedirectToAction("WorkoutList"));
}
// GET: Workout
public async Task <ActionResult> Index()
{
if (!User.Identity.IsAuthenticated)
{
return(View("NotAuthenticated"));
}
IdentityUser user = await _userManager.GetUserAsync(User);
var workouts = _context.Workout.Where(w => w.AspNetUserId == user.Id).ToList();
var exercises = _context.Exercise.ToDictionary(x => x.ExerciseId, x => x);
foreach (var w in workouts)
{
w.WorkoutToExercise = _context.WorkoutToExercise.Where(we => we.WorkoutId == w.WorkoutId && we.Active).ToList();
foreach (var we in w.WorkoutToExercise)
{
we.Exercise = exercises[we.ExerciseId];
}
w.WorkoutSet = _context.WorkoutSet.Where(ws => ws.WorkoutId == w.WorkoutId && ws.Active).OrderBy(ws => ws.SetOrder).ToList();
}
List <WorkoutVM> workoutViewModels = new List <WorkoutVM>();
foreach (var w in workouts)
{
WorkoutVM workoutVM = new WorkoutVM(w);
Dictionary <string, List <string> > exerciseToSets = new Dictionary <string, List <string> >();
List <WorkoutToExercise> wtes = w.WorkoutToExercise.OrderBy(x => x.Order).ToList();
foreach (var wte in wtes)
{
foreach (var ws in wte.Workout.WorkoutSet.Where(ws => ws.ExerciseId == wte.ExerciseId && ws.Active).OrderBy(x => x.SetOrder))
{
if (exerciseToSets.ContainsKey(ws.Exercise.ExerciseName))
{
exerciseToSets[ws.Exercise.ExerciseName].Add(ws.Reps.ToString());
}
else
{
exerciseToSets[ws.Exercise.ExerciseName] = new List <string> {
ws.Reps.ToString()
};
}
}
}
workoutVM.ExerciseDisplay = exerciseToSets;
workoutViewModels.Add(workoutVM);
}
return(View(workoutViewModels));
}
// GET: Workout/Create
public ActionResult Create()
{
var vm = new WorkoutVM();
vm.Workout = new Workout();
vm.AllExercises = _context.Exercise.ToList().Select(x => new ExerciseVM {
ExerciseID = x.ExerciseId, ExerciseName = x.ExerciseName
}).ToList();
return(View(vm));
}
public ActionResult Workout()
{
Database db = new Database();
WorkoutVM model = new WorkoutVM();
if (null != Session["UserId"])
{
model.UserTracks = db.GetTrackByCreator((int)Session["UserId"]);
model.Workouts = db.GetWorkoutsByUserId((int)Session["UserId"]);
}
return(View(model));
}
public HttpResponseMessage Patch(WorkoutVM workoutVM)
{
try
{
_service.EditWorkout(workoutVM);
return(Request.CreateResponse(HttpStatusCode.NotImplemented));
}
catch (Exception ex)
{
return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, ex));
}
}
// GET: Workout
public ActionResult Index()
{
var workouts = _context.Workout.ToList();
var exercises = _context.Exercise.ToDictionary(x => x.ExerciseId, x => x);
foreach (var w in workouts)
{
w.WorkoutToExercise = _context.WorkoutToExercise.Where(we => we.WorkoutId == w.WorkoutId && we.Active).ToList();
foreach (var we in w.WorkoutToExercise)
{
we.Exercise = exercises[we.ExerciseId];
}
w.WorkoutSet = _context.WorkoutSet.Where(ws => ws.WorkoutId == w.WorkoutId && ws.Active).OrderBy(ws => ws.SetOrder).ToList();
}
List <WorkoutVM> workoutViewModels = new List <WorkoutVM>();
foreach (var w in workouts)
{
WorkoutVM workoutVM = new WorkoutVM(w);
Dictionary <string, List <string> > exerciseToSets = new Dictionary <string, List <string> >();
List <WorkoutToExercise> wtes = w.WorkoutToExercise.OrderBy(x => x.Order).ToList();
foreach (var wte in wtes)
{
foreach (var ws in wte.Workout.WorkoutSet.Where(ws => ws.ExerciseId == wte.ExerciseId && ws.Active).OrderBy(x => x.SetOrder))
{
if (exerciseToSets.ContainsKey(ws.Exercise.ExerciseName))
{
exerciseToSets[ws.Exercise.ExerciseName].Add(ws.Reps.ToString());
}
else
{
exerciseToSets[ws.Exercise.ExerciseName] = new List <string> {
ws.Reps.ToString()
};
}
}
}
workoutVM.ExerciseDisplay = exerciseToSets;
workoutViewModels.Add(workoutVM);
}
return(View(workoutViewModels));
}
public static Workout WorkoutToWorkoutVM(WorkoutVM workoutVM)
{
var workout = new Workout()
{
WorkoutId = workoutVM.WorkoutId,
Distance = workoutVM.Distance,
TotalTime = workoutVM.TotalTime,
Notes = workoutVM.Notes,
DiaryFeelingId = workoutVM.DiaryFeelingId,
WorkoutTypeId = workoutVM.WorkoutTypeId
};
return(workout);
}
public ActionResult EditWorkout(int id)
{
IWorkoutRepo repo = WorkoutRepoFactory.Create();
var workout = repo.GetWorkoutById(id);
var model = new WorkoutVM
{
WorkoutID = workout.WorkoutID,
WorkoutName = workout.WorkoutName,
WorkoutDescription = workout.WorkoutDescription,
ClientsOnWorkout = workout.ClientsOnWorkout,
TrainerCreator = workout.TrainerCreator
};
return(View(model));
}
public HttpResponseMessage Post(WorkoutVM workoutVM)
{
try
{
if (workoutVM.DiaryFeelingId == 0)
{
return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, "A workout without dialy feeling id can't be added to the system"));
}
_service.AddWorkout(workoutVM);
return(Request.CreateResponse(HttpStatusCode.Created, workoutVM));
}
catch (Exception ex)
{
return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, ex));
}
}
// GET: Workout/Create
public ActionResult Create()
{
if (!User.Identity.IsAuthenticated)
{
return(View("NotAuthenticated"));
}
var vm = new WorkoutVM();
vm.Workout = new Workout.Models.Workout();
vm.AllExercises = _context.Exercise.ToList().Select(x => new ExerciseVM {
ExerciseID = x.ExerciseId, ExerciseName = x.ExerciseName
}).ToList();
return(View(vm));
}
public ActionResult EditWorkout(WorkoutVM workoutVM)
{
Workout workout = workoutVM.Workout;
workout.WorkoutSet = _context.WorkoutSet.Where(ws => ws.WorkoutId == workout.WorkoutId).ToList();
workout.WorkoutToExercise = _context.WorkoutToExercise.Where(wte => wte.WorkoutId == workout.WorkoutId).ToList();
foreach (var wte in workout.WorkoutToExercise)
{
wte.Active = false;
}
foreach (var ws in workout.WorkoutSet)
{
ws.Active = false;
}
_context.WorkoutSet.UpdateRange(workout.WorkoutSet);
_context.WorkoutToExercise.UpdateRange(workout.WorkoutToExercise);
_context.SaveChanges();
workoutVM.Workout.WorkoutToExercise = workoutVM.AllExercises
.Where(e => e.Selected)
.Select(x => new WorkoutToExercise {
Workout = workout, ExerciseId = x.ExerciseID, Order = x.Order, Active = true
})
.ToList();
workoutVM.AllExercises = workoutVM.AllExercises.Where(e => e.Selected).ToList();
workoutVM.Workout.WorkoutSet = GetWorkOutSets(workoutVM, workoutVM.Workout);
_context.Workout.Update(workout);
_context.SaveChanges();
return(RedirectToAction("Index"));
//comment -
}
//public void Add(int userid, WorkoutVM model)
//{
// var workout = new Workout(userid, model.starttime, model.endtime);
// List<WorkoutExcercise> exList = new List<WorkoutExcercise>();
// foreach (var exercise in model.exercises)
// {
// exList.Add(new WorkoutExcercise(workout, exercise));
// }
// workout.Excercises = exList;
// _context.Add(workout);
// _context.SaveChanges();
//}
public void Update(WorkoutVM model)
{
var workout = _context.Workouts.Find(model.id);
workout.StartTime = model.starttime;
workout.EndTime = model.endtime;
foreach (var exercise in model.exercises)
{
if (!workout.Excercises.Any(e => e.ExcerciseId == exercise.Id))
{
var newexercise = _context.Excercises.Find(exercise.Id);
workout.Excercises.Add(new WorkoutExcercise(workout, newexercise));
}
}
_context.Update(workout);
_context.SaveChanges();
}
//[ValidateAntiForgeryToken]
public async Task <ActionResult> Create([FromForm] WorkoutVM workoutVM)
{
if (!User.Identity.IsAuthenticated)
{
return(View("NotAuthenticated"));
}
var workout = new Workout.Models.Workout();
workout.DateCreated = DateTime.Now;
workout.CreatedBy = 1;
workout.WorkoutName = workoutVM.Workout.WorkoutName;
workout.WorkoutToExercise = workoutVM.AllExercises.Where(e => e.Selected).Select(x => new WorkoutToExercise {
Workout = workout, ExerciseId = x.ExerciseID, Order = x.Order, Active = true
}).ToList();
workoutVM.AllExercises = workoutVM.AllExercises.Where(e => e.Selected).ToList();
IdentityUser user = await _userManager.GetUserAsync(User);
workout.AspNetUserId = user.Id;
workout.WorkoutSet = GetWorkOutSets(workoutVM, workout);
try
{
if (ModelState.IsValid)
{
_context.Workout.Add(workout);
_context.SaveChanges();
return(RedirectToAction("Index"));
}
}
catch (Exception ex)
{
ModelState.AddModelError("", "Unable to save changes. Try again, and if the problem persists see your system administrator.");
}
return(View(workout));
}
public ActionResult EditWorkout([FromRoute] int id)
{
Workout workout = _context.Workout
.Where(w => w.WorkoutId == id)
.Single();
//*******************************************
//var workouts = _context.Workout.ToList();
var exercises = _context.Exercise.ToList();
workout.WorkoutToExercise = _context.WorkoutToExercise.Where(we => we.WorkoutId == workout.WorkoutId && we.Active).ToList();
foreach (var we in workout.WorkoutToExercise)
{
we.Exercise = exercises.Where(e => e.ExerciseId == we.ExerciseId).Single();
}
workout.WorkoutSet = _context.WorkoutSet.Where(ws => ws.WorkoutId == workout.WorkoutId && ws.Active).OrderBy(ws => ws.SetOrder).ToList();
WorkoutVM workoutVM = new WorkoutVM(workout);
Dictionary <string, List <string> > exerciseToSets = new Dictionary <string, List <string> >();
List <WorkoutToExercise> wtes = workout.WorkoutToExercise.OrderBy(x => x.Order).ToList();
foreach (var wte in wtes)
{
foreach (var ws in wte.Workout.WorkoutSet.Where(ws => ws.ExerciseId == wte.ExerciseId).OrderBy(x => x.SetOrder))
{
if (exerciseToSets.ContainsKey(ws.Exercise.ExerciseName))
{
exerciseToSets[ws.Exercise.ExerciseName].Add(ws.Reps.ToString());
}
else
{
exerciseToSets[ws.Exercise.ExerciseName] = new List <string> {
ws.Reps.ToString()
};
}
}
}
workoutVM.ExerciseDisplay = exerciseToSets;// exerciseToSets.Select(kvp => kvp.Key + " | " + string.Join(", ", kvp.Value)).ToList();
foreach (ExerciseVM evm in workoutVM.AllExercises)
{
evm.SetsAndReps = string.Join(", ", exerciseToSets[evm.ExerciseName]);
evm.Order = wtes.Where(wte => wte.Exercise.ExerciseName == evm.ExerciseName).Single().Order;
evm.Selected = true;
evm.ExerciseID = wtes.Where(wte => wte.Exercise.ExerciseName == evm.ExerciseName).Single().ExerciseId;
}
workoutVM.AllExercises = workoutVM.AllExercises.OrderBy(e => e.Order).ToList();
HashSet <int> exerciseIDs = workoutVM.AllExercises.Select(ex => ex.ExerciseID).ToHashSet();
workoutVM.AllExercises.AddRange(exercises.Where(e => !exerciseIDs.Contains(e.ExerciseId)).Select(e => new ExerciseVM {
ExerciseID = e.ExerciseId, ExerciseName = e.ExerciseName
}));
//*******************************************
//workout.WorkoutToExercise = _context.WorkoutToExercise.Where(we => we.WorkoutId == workout.WorkoutId).ToList();
//workout.WorkoutSet = _context.WorkoutSet.Where(ws => ws.WorkoutId == workout.WorkoutId).ToList();
//foreach (var we in workout.WorkoutToExercise)
//{
// we.Exercise = _context.Exercise.Where(e => e.ExerciseId == we.ExerciseId).Single();
//}
//var vm = new WorkoutVM();
//vm.Workout = workout;
//vm.AllExercises = workout.WorkoutSet.Select(ws => ws.Exercise)
// .ToList().Select(x => new ExerciseVM { ExerciseID = x.ExerciseId, ExerciseName = x.ExerciseName })
// .ToList();
//foreach (var ws in workout.WorkoutSet)
//{
//}
return(View("Edit", workoutVM));
}
//todo add more values to get paging, at least 12
public static List <DailyFeelingVM> GetDailyEntriesVMWithWorkouts()
{
var dailyFeelingWithWorkouts = new List <DailyFeelingVM>();
var dailyFeeling1 = new DailyFeelingVM()
{
DailyFeelingId = 1,
Date = new DateTime(2015, 1, 1),
Fatigue = 5,
Sleep = 5,
Soreness = 4,
Stress = 5,
Notes = "",
RestingHeartRate = 60,
Weight = 69,
WorkoutsVM = new List <WorkoutVM>()
};
var workoutVM1 = new WorkoutVM()
{
DiaryFeelingId = 1,
WorkoutId = 1,
WorkoutTypeId = 2,
WorkoutTypeName = "Running",
Distance = 13
};
dailyFeeling1.WorkoutsVM.Add(workoutVM1);
dailyFeelingWithWorkouts.Add(dailyFeeling1);
var dailyFeeling2 = new DailyFeelingVM()
{
DailyFeelingId = 2,
Date = new DateTime(2015, 1, 2),
Fatigue = 5,
Sleep = 5,
Soreness = 4,
Stress = 5,
Notes = "",
RestingHeartRate = 60,
Weight = (decimal)68.7,
WorkoutsVM = new List <WorkoutVM>()
};
var workoutVM2 = new WorkoutVM()
{
DiaryFeelingId = 2,
WorkoutId = 1,
WorkoutTypeId = 1,
WorkoutTypeName = "Swiming",
Distance = 1200
};
dailyFeeling2.WorkoutsVM.Add(workoutVM2);
dailyFeelingWithWorkouts.Add(dailyFeeling2);
var dailyFeeling3 = new DailyFeelingVM()
{
DailyFeelingId = 3,
Date = new DateTime(2015, 1, 3),
Fatigue = 5,
Sleep = 5,
Soreness = 4,
Stress = 5,
Notes = "",
RestingHeartRate = 59,
Weight = (decimal)68.5,
WorkoutsVM = new List <WorkoutVM>()
};
var workoutVM3 = new WorkoutVM()
{
DiaryFeelingId = 3,
WorkoutId = 1,
WorkoutTypeId = 1,
WorkoutTypeName = "Swiming",
Distance = 1200
};
var workoutVM4 = new WorkoutVM()
{
DiaryFeelingId = 3,
WorkoutId = 1,
WorkoutTypeId = 2,
WorkoutTypeName = "Running",
Distance = 12
};
dailyFeeling3.WorkoutsVM.Add(workoutVM3);
dailyFeeling3.WorkoutsVM.Add(workoutVM4);
dailyFeelingWithWorkouts.Add(dailyFeeling3);
var dailyFeeling5 = new DailyFeelingVM()
{
DailyFeelingId = 5,
Date = new DateTime(2015, 1, 5),
Fatigue = 4,
Sleep = 5,
Soreness = 4,
Stress = 5,
Notes = "",
RestingHeartRate = 60,
Weight = (decimal)68.5,
WorkoutsVM = new List <WorkoutVM>()
};
var workoutVM5 = new WorkoutVM()
{
DiaryFeelingId = 5,
WorkoutId = 1,
WorkoutTypeId = 1,
WorkoutTypeName = "Swiming",
Distance = 1200
};
dailyFeeling5.WorkoutsVM.Add(workoutVM5);
dailyFeelingWithWorkouts.Add(dailyFeeling5);
var dailyFeeling6 = new DailyFeelingVM()
{
DailyFeelingId = 6,
Date = new DateTime(2015, 1, 6),
Fatigue = 4,
Sleep = 5,
Soreness = 4,
Stress = 5,
Notes = "",
RestingHeartRate = 60,
Weight = (decimal)68,
WorkoutsVM = new List <WorkoutVM>()
};
var workoutVM6 = new WorkoutVM()
{
DiaryFeelingId = 6,
WorkoutId = 1,
WorkoutTypeId = 2,
WorkoutTypeName = "Runnning",
Distance = 14
};
dailyFeeling6.WorkoutsVM.Add(workoutVM6);
dailyFeelingWithWorkouts.Add(dailyFeeling6);
var dailyFeeling7 = new DailyFeelingVM()
{
DailyFeelingId = 7,
Date = new DateTime(2015, 1, 7),
Fatigue = 5,
Sleep = 5,
Soreness = 5,
Stress = 5,
Notes = "",
RestingHeartRate = 60,
Weight = (decimal)68.9,
WorkoutsVM = new List <WorkoutVM>()
};
var workoutVM7 = new WorkoutVM()
{
DiaryFeelingId = 7,
WorkoutId = 1,
WorkoutTypeId = 1,
WorkoutTypeName = "Swimming",
Distance = 1200
};
dailyFeeling7.WorkoutsVM.Add(workoutVM7);
dailyFeelingWithWorkouts.Add(dailyFeeling7);
var dailyFeeling8 = new DailyFeelingVM()
{
DailyFeelingId = 8,
Date = new DateTime(2015, 1, 8),
Fatigue = 4,
Sleep = 4,
Soreness = 4,
Stress = 5,
Notes = "",
RestingHeartRate = 60,
Weight = (decimal)68.9,
WorkoutsVM = new List <WorkoutVM>()
};
var workoutVM8 = new WorkoutVM()
{
DiaryFeelingId = 8,
WorkoutId = 1,
WorkoutTypeId = 2,
WorkoutTypeName = "Runnning",
Distance = 14
};
dailyFeeling8.WorkoutsVM.Add(workoutVM8);
dailyFeelingWithWorkouts.Add(dailyFeeling8);
var dailyFeeling10 = new DailyFeelingVM()
{
DailyFeelingId = 10,
Date = new DateTime(2015, 1, 10),
Fatigue = 5,
Sleep = 5,
Soreness = 3,
Stress = 5,
Notes = "",
RestingHeartRate = 60,
Weight = (decimal)68,
WorkoutsVM = new List <WorkoutVM>()
};
var workoutVM10 = new WorkoutVM()
{
DiaryFeelingId = 10,
WorkoutId = 1,
WorkoutTypeId = 1,
WorkoutTypeName = "Swimming",
Distance = 1200
};
dailyFeeling10.WorkoutsVM.Add(workoutVM10);
dailyFeelingWithWorkouts.Add(dailyFeeling10);
var dailyFeeling11 = new DailyFeelingVM()
{
DailyFeelingId = 11,
Date = new DateTime(2015, 1, 11),
Fatigue = 4,
Sleep = 4,
Soreness = 3,
Stress = 5,
Notes = "",
RestingHeartRate = 60,
Weight = (decimal)69.5,
WorkoutsVM = new List <WorkoutVM>()
};
var workoutVM11 = new WorkoutVM()
{
DiaryFeelingId = 11,
WorkoutId = 1,
WorkoutTypeId = 2,
WorkoutTypeName = "Runnning",
Distance = 17
};
dailyFeeling11.WorkoutsVM.Add(workoutVM11);
dailyFeelingWithWorkouts.Add(dailyFeeling11);
var dailyFeeling12 = new DailyFeelingVM()
{
DailyFeelingId = 12,
Date = new DateTime(2015, 1, 12),
Fatigue = 5,
Sleep = 5,
Soreness = 5,
Stress = 5,
Notes = "",
RestingHeartRate = 60,
Weight = (decimal)67.7,
WorkoutsVM = new List <WorkoutVM>()
};
var workoutVM12 = new WorkoutVM()
{
DiaryFeelingId = 12,
WorkoutId = 1,
WorkoutTypeId = 1,
WorkoutTypeName = "Swimming",
Distance = 1200
};
dailyFeeling12.WorkoutsVM.Add(workoutVM12);
dailyFeelingWithWorkouts.Add(dailyFeeling12);
var dailyFeeling14 = new DailyFeelingVM()
{
DailyFeelingId = 14,
Date = new DateTime(2015, 1, 14),
Fatigue = 4,
Sleep = 5,
Soreness = 4,
Stress = 5,
Notes = "",
RestingHeartRate = 60,
Weight = (decimal)68,
WorkoutsVM = new List <WorkoutVM>()
};
var workoutVM14 = new WorkoutVM()
{
DiaryFeelingId = 14,
WorkoutId = 1,
WorkoutTypeId = 2,
WorkoutTypeName = "Runnning",
Distance = 12
};
dailyFeeling14.WorkoutsVM.Add(workoutVM14);
dailyFeelingWithWorkouts.Add(dailyFeeling14);
return(dailyFeelingWithWorkouts);
}
