protected void Page_Load(object sender, EventArgs e)
{
if (!IsPostBack)
{
WorkoutViewModel workout = bll.GetWorkoutById(Convert.ToInt32(Request.QueryString["WorkoutID"]));
Exercise1.Text = workout.Exercise1;
Exercise1Reps.Text = workout.Exercise1Reps;
Exercise1Sets.Text = workout.Exercise1Sets;
Exercise2.Text = workout.Exercise2;
Exercise2Reps.Text = workout.Exercise2Reps;
Exercise2Sets.Text = workout.Exercise2Sets;
Exercise3.Text = workout.Exercise3;
Exercise3Reps.Text = workout.Exercise3Reps;
Exercise3Sets.Text = workout.Exercise3Sets;
Exercise4.Text = workout.Exercise4;
Exercise4Reps.Text = workout.Exercise4Reps;
Exercise4Sets.Text = workout.Exercise4Sets;
Exercise5.Text = workout.Exercise5;
Exercise5Reps.Text = workout.Exercise5Reps;
Exercise5Sets.Text = workout.Exercise5Sets;
}
}
protected void WorkoutEditButton_Click(object sender, EventArgs e)
{
if (Page.IsValid)
{
WorkoutViewModel workout = new WorkoutViewModel();
workout.WorkoutID = Convert.ToInt32(Request.QueryString["WorkoutID"]);
workout.Exercise1 = Exercise1.Text;
workout.Exercise1Reps = Exercise1Reps.Text;
workout.Exercise1Sets = Exercise1Sets.Text;
workout.Exercise2 = Exercise2.Text;
workout.Exercise2Reps = Exercise2Reps.Text;
workout.Exercise2Sets = Exercise2Sets.Text;
workout.Exercise3 = Exercise3.Text;
workout.Exercise3Reps = Exercise3Reps.Text;
workout.Exercise3Sets = Exercise3Sets.Text;
workout.Exercise4 = Exercise4.Text;
workout.Exercise4Reps = Exercise4Reps.Text;
workout.Exercise4Sets = Exercise4Sets.Text;
workout.Exercise5 = Exercise5.Text;
workout.Exercise5Reps = Exercise5Reps.Text;
workout.Exercise5Sets = Exercise5Sets.Text;
bll.EditWorkout(workout);
Response.Redirect("~/Workouts.aspx");
}
}
public ActionResult AddWorkout(WorkoutViewModel vm)
{
var userId = User.Identity.GetUserId();
var user = UserManager.FindById(userId);
var ctx = new ApplicationDbContext();
if (user.ListOfWorkouts == null)
{
IEnumerable <Workout> workouts = new List <Workout>();
}
var workout = new Workout()
{
Title = vm.Title,
DateOfWorkout = vm.DateOfWorkout,
StartAt = vm.StartAt,
EndAt = vm.EndAt,
Sport = vm.Sport,
ApplicationUserID = userId,
};
ctx.Workouts.Add(workout);
ctx.SaveChanges();
return(RedirectToAction("History"));
}
protected void Page_Load(object sender, EventArgs e)
{
if (!IsPostBack)
{
TraineeViewModel trainee = trainee_BLL.GetTraineeById(Convert.ToInt32(Request.QueryString["TraineeID"]));
TraineeNameLabel.Text = trainee.FirstName + " " + trainee.LastName;
if (trainee.WorkoutID != 0)
{
WorkoutViewModel workout = workout_BLL.GetWorkoutById(trainee.WorkoutID);
WorkoutNameLabel.Text = workout.WorkoutName;
Exercise1Label.Text = workout.DisplayExercise1;
Exercise2Label.Text = workout.DisplayExercise2;
Exercise3Label.Text = workout.DisplayExercise3;
Exercise4Label.Text = workout.DisplayExercise4;
Exercise5Label.Text = workout.DisplayExercise5;
}
else
{
NoWorkoutLabel.Text = "There is no Workout Assigned to: ";
}
}
}
public async Task CreateAsync_Maps_Posts_And_Completes_When_ApiCall_Succeeds()
{
// Arrange
var expectedWorkoutViewModel = new WorkoutViewModel {
Name = "Test workout 01"
};
var expectedWorkout = new Workout {
Name = "Test workout 01"
};
MapperMock
.Setup(x => x.Map <WorkoutViewModel, Workout>(expectedWorkoutViewModel))
.Returns(expectedWorkout)
.Verifiable();
HttpClientMock
.Setup(x => x.PostEntityAsync(It.IsAny <string>(), expectedWorkout))
.ReturnsAsync(new HttpResponseMessage
{
StatusCode = HttpStatusCode.OK,
Content = new StringContent("Content as string")
})
.Verifiable();
// Act
await ServiceUnderTest.CreateAsync(expectedWorkoutViewModel);
// Assert
MapperMock.Verify(x => x.Map <WorkoutViewModel, Workout>(expectedWorkoutViewModel), Times.Once);
HttpClientMock.Verify(x => x.PostEntityAsync(It.IsAny <string>(), expectedWorkout), Times.Once);
}
public async Task CreateAsync_Maps_Posts_And_Throws_HttpRequestException_When_ApiCall_Fails()
{
// Arrange
var expectedWorkoutViewModel = new WorkoutViewModel {
Name = "Test workout 01"
};
var expectedWorkout = new Workout {
Name = "Test workout 01"
};
MapperMock
.Setup(x => x.Map <WorkoutViewModel, Workout>(expectedWorkoutViewModel))
.Returns(expectedWorkout)
.Verifiable();
HttpClientMock
.Setup(x => x.PostEntityAsync(It.IsAny <string>(), expectedWorkout))
.ReturnsAsync(new HttpResponseMessage
{
StatusCode = HttpStatusCode.InternalServerError,
Content = new StringContent("Content as string")
})
.Verifiable();
// Act, Assert
await Assert.ThrowsAsync <HttpRequestException>(() =>
ServiceUnderTest.CreateAsync(expectedWorkoutViewModel));
MapperMock.Verify(x => x.Map <WorkoutViewModel, Workout>(expectedWorkoutViewModel), Times.Once);
HttpClientMock.Verify(x => x.PostEntityAsync(It.IsAny <string>(), expectedWorkout), Times.Once);
}
public ActionResult Add_workout(WorkoutViewModel workoutView)
{
if (ModelState.IsValid)
{
var workout = new Workout()
{
Id = workoutView.Id, Workout_category = workoutView.Workout_category, Workout_title = workoutView.Workout_title, status = "inactive", calories_perminute = workoutView.calories_perminute
};
var isAdded = workrepo.Add(workout);
if (isAdded)
{
return(RedirectToAction(""));
}
else
{
ModelState.AddModelError("", "Failed to add");
return(View(workoutView));
}
}
else
{
ModelState.AddModelError("", "One or more validations failed");
return(View(workoutView));
}
}
public int SaveWorkoutAsync(WorkoutViewModel viewModel, int id = 0)
{
var workout = new Workout();
if (id != 0)
{
workout = _context.Workout.Find(id);
if (workout == null)
{
return(0);
}
if (viewModel.Exercises != null)
{
workout.Exercises = viewModel.Exercises;
}
}
workout.PersonWorkout = viewModel.PersonWorkout;
workout.Name = viewModel.Name;
workout.Description = viewModel.Description;
workout.TagID = viewModel.TagId;
//workout.Exercises = viewModel.Exercises;
if (id == 0)
{
_context.Workout.Add(workout);
_context.SaveChanges();
return(_context.Workout.LastAsync().Result.WorkoutID);
}
_context.Update(workout);
_context.SaveChanges();
return(id);
}
public ActionResult CompleteWorkout(WorkoutViewModel model)
{
if (Session["ClientId"] == null && !(User.IsInRole("System Administrator") || User.IsInRole("Coach")))
{
string loggedInUserId = HttpContext.GetOwinContext().Authentication.User.Claims.First(x => x.Type == ClaimTypes.NameIdentifier).Value;
model.UserId = Convert.ToInt32(loggedInUserId);
}
else
{
model.UserId = Convert.ToInt32(Session["ClientId"].ToString());
}
JObject jObj = QueryMicroService(CompleteWorkoutEndpoint, "POST", JsonConvert.SerializeObject(model));
string message = "";
if (jObj["status"].ToString() == "OK")
{
message = jObj["result"].ToString();
}
else
{
message = $"Failed to complete workout.\n{jObj["result"].ToString()}";
}
return(Json(new { message }, JsonRequestBehavior.AllowGet));
}
protected void WorkoutAddButton_Click(object sender, EventArgs e)
{
if (Page.IsValid)
{
string connectionString = ConfigurationManager.ConnectionStrings["MySwoleMateConnectionString"].ToString();
WorkoutBLL bll = new WorkoutBLL(connectionString);
WorkoutViewModel workout = new WorkoutViewModel();
workout.Exercise1 = Exercise1.Text;
workout.Exercise1Reps = Exercise1Reps.Text;
workout.Exercise1Sets = Exercise1Sets.Text;
workout.Exercise2 = Exercise2.Text;
workout.Exercise2Reps = Exercise2Reps.Text;
workout.Exercise2Sets = Exercise2Sets.Text;
workout.Exercise3 = Exercise3.Text;
workout.Exercise3Reps = Exercise3Reps.Text;
workout.Exercise3Sets = Exercise3Sets.Text;
workout.Exercise4 = Exercise4.Text;
workout.Exercise4Reps = Exercise4Reps.Text;
workout.Exercise4Sets = Exercise4Sets.Text;
workout.Exercise5 = Exercise5.Text;
workout.Exercise5Reps = Exercise5Reps.Text;
workout.Exercise5Sets = Exercise5Sets.Text;
bll.AddWorkout(workout);
Response.Redirect("~/Workouts.aspx");
}
}
protected void Page_Load(object sender, EventArgs e)
{
if (!IsPostBack)
{
string connectionString = ConfigurationManager.ConnectionStrings["MySwoleMateConnectionString"].ToString();
TraineeBLL tbll = new TraineeBLL(connectionString);
TraineeViewModel trainee = tbll.GetTraineeById(Convert.ToInt32(Request.QueryString["TraineeID"]));
MainTitle.Text = "Workout Assigned to " + trainee.FirstName + " " + trainee.LastName;
WorkoutBLL bll = new WorkoutBLL(connectionString);
//int workoutID = Convert.ToInt32(Request.QueryString["WorkoutID"]);
int workoutID = trainee.WorkoutID;
if (workoutID != 0)
{
WorkoutViewModel workout = bll.GetWorkoutById(workoutID);
Exercise1.Text = workout.DisplayExercise1;
Exercise2.Text = workout.DisplayExercise2;
Exercise3.Text = workout.DisplayExercise3;
Exercise4.Text = workout.DisplayExercise4;
Exercise5.Text = workout.DisplayExercise5;
}
else
{
Exercise1.Text = "No workout assigned";
}
}
}
private void BindData()
{
TraineeViewModel trainee = traineeBLL.GetTraineeById(Convert.ToInt32(Request.QueryString["TraineeID"]));
TraineeName.Text = (trainee.FirstName + " " + trainee.LastName).ToUpper();;
AssignWorkOutLink.NavigateUrl += Request.QueryString["TraineeID"];
// Check to see if the trainee has been assigned a workout plan.
// Display the workout plan if they have or display message of missing workout
if (traineeBLL.HasWorkoutAssigned(trainee.TraineeID))
{
WorkoutViewModel workout = workoutBLL.GetWorkoutById(trainee.WorkoutID);
NoWorkoutHeader.Visible = false;
WorkoutName.Text = workout.WorkoutName;
DisplayExercise1.Text = workout.DisplayExercise1;
DisplayExercise2.Text = workout.DisplayExercise2;
DisplayExercise3.Text = workout.DisplayExercise3;
DisplayExercise4.Text = workout.DisplayExercise4;
DisplayExercise5.Text = workout.DisplayExercise5;
}
else
{
ExerciseList.Visible = false;
}
}
public async Task <ActionResult <Workout> > SaveWorkout([FromBody] WorkoutViewModel workoutViewModel)
{
Workout entity;
if (workoutViewModel.Id == 0)
{
entity = await _workoutService.CreateNewAsync();
entity.User = await _applicationUserService.GetCurrentUserAsync(User);
}
else
{
entity = await _workoutService.GetWorkoutByIdAsync(workoutViewModel.Id);
if (entity == null)
{
return(BadRequest());
}
}
workoutViewModel.Update(entity);
await _workoutService.SaveChangesAsync();
return(Ok(new WorkoutViewModel(entity)));
}
/// <summary>
/// Method for Load event to load values into the form for edit
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
protected void Page_Load(object sender, EventArgs e)
{
//Only load the values if the request is not a PostBack
if (!IsPostBack)
{
//We pass the WorkoutID by a Query String from the GridView on Workout.aspx.
WorkoutViewModel workout = bll.GetWorkoutById(Convert.ToInt32(Request.QueryString["WorkoutID"]));
//We use the GetWorkoutById method to get the Workout from the database, which we use to
//populate the data into the form.
WorkoutName.Text = workout.WorkoutName;
Exercise1.Text = workout.Exercise1;
Exercise1Sets.Text = workout.Exercise1Sets.ToString();
Exercise1Reps.Text = workout.Exercise1Reps.ToString();
Exercise2.Text = workout.Exercise2;
Exercise2Sets.Text = workout.Exercise2Sets.ToString();
Exercise2Reps.Text = workout.Exercise2Reps.ToString();
Exercise3.Text = workout.Exercise3;
Exercise3Sets.Text = workout.Exercise3Sets.ToString();
Exercise3Reps.Text = workout.Exercise3Reps.ToString();
Exercise4.Text = workout.Exercise4;
Exercise4Sets.Text = workout.Exercise4Sets.ToString();
Exercise4Reps.Text = workout.Exercise4Reps.ToString();
Exercise5.Text = workout.Exercise5;
Exercise5Sets.Text = workout.Exercise5Sets.ToString();
Exercise5Reps.Text = workout.Exercise5Reps.ToString();
}
}
public async Task ReadOneAsync_Gets_Maps_And_Returns_A_Workout_When_ApiCall_Returns_Workout()
{
// Arrange
const int id = 1;
var expectedWorkout = new Workout {
Name = "Test workout 01", Id = id
};
var expectedWorkoutViewModel = new WorkoutViewModel {
Name = "Test workout 01", Id = id
};
HttpClientMock
.Setup(x => x.GetStringAsync(It.IsAny <string>()))
.ReturnsAsync(JsonConvert.SerializeObject(expectedWorkout))
.Verifiable();
MapperMock
.Setup(x => x.Map <Workout, WorkoutViewModel>(It.IsAny <Workout>()))
.Returns(expectedWorkoutViewModel)
.Verifiable();
// Act
var result = await ServiceUnderTest.ReadOneAsync(id);
// Assert
Assert.Same(expectedWorkoutViewModel, result);
HttpClientMock.Verify(x => x.GetStringAsync(It.IsAny <string>()), Times.Once);
MapperMock.Verify(x => x.Map <Workout, WorkoutViewModel>(It.IsAny <Workout>()), Times.Once);
}
public JsonResult Post([FromBody] WorkoutViewModel vm)
{
try {
if (ModelState.IsValid)
{
// Map from VM to model so we can save it in database
var newWorkout = Mapper.Map <Workout>(vm);
newWorkout.username = User.Identity.Name;
// Save to the Database
_logger.LogInformation("Attemting to save a new workout to the database");
_repository.addWorkout(newWorkout);
if (_repository.saveAll())
{
Response.StatusCode = (int)HttpStatusCode.Created;
return(Json(Mapper.Map <WorkoutViewModel>(newWorkout)));
}
}
}
catch (Exception ex)
{
_logger.LogError("Could not post to the database", ex);
Response.StatusCode = (int)HttpStatusCode.BadRequest;
return(Json(new { Message = ex.Message }));
}
Response.StatusCode = (int)HttpStatusCode.BadRequest;
return(Json(new { message = "Faild", ModelState = ModelState }));
}
public IActionResult Select(SelectWorkoutViewModel selectWorkoutViewModel, DateTime date)
{
// show a list of EXERCISES
IList <WorkoutViewModel> exercises = new List <WorkoutViewModel>();
//pull all the ExerciseIDs (aka SelectedExercise) in the database for the DATE selected
var exerciseIDsInSelectedWorkout = context
.Workouts
.Where(w => w.Date == date)
.Select(w => w.SelectedExercise)
.ToList();
// each ID in a list of IDs
foreach (var exerciseID in exerciseIDsInSelectedWorkout)
{
//convert each ExerciseIDs to its Name
var name = context
.Exercises
.Where(e => e.ID == exerciseID)
.Select(m => m.Name)
.FirstOrDefault();
// attach the exercise names to the ViewModel
WorkoutViewModel newWorkoutViewModel = new WorkoutViewModel();
newWorkoutViewModel.Name = name;
newWorkoutViewModel.ID = exerciseID;
exercises.Add(newWorkoutViewModel);
}
//include the variable name for the list of selected exercises in the View()
return(View("Workout", exercises));
}
/// <summary>
/// Add Workout to DB from user input form
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
protected void WorkoutAddButton_Click(object sender, EventArgs e)
{
//Checks to see if all Validation Controls are valid
if (Page.IsValid)
{
//Grab connectionString from web.config file
string connectionString = ConfigurationManager.ConnectionStrings["MySwoleMateConnectionString"].ToString();
//Create new instance of WorkoutBLL
WorkoutBLL bll = new WorkoutBLL(connectionString);
//Create new instance of ViewModel with data from the user
WorkoutViewModel workout = new WorkoutViewModel();
//The Text property of each control will contain the data from the user
workout.WorkoutName = WorkoutName.Text;
workout.Exercise1 = Exercise1.Text;
workout.Exercise2 = Exercise2.Text;
workout.Exercise3 = Exercise3.Text;
workout.Exercise4 = Exercise4.Text;
workout.Exercise5 = Exercise5.Text;
//Since the Text property returns a string, some properties would need to be converted
workout.Exercise1Sets = Convert.ToInt32(Exercise1Sets.Text);
workout.Exercise1Reps = Convert.ToInt32(Exercise1Reps.Text);
workout.Exercise2Sets = Convert.ToInt32(Exercise2Sets.Text);
workout.Exercise2Reps = Convert.ToInt32(Exercise2Reps.Text);
workout.Exercise3Sets = Convert.ToInt32(Exercise3Sets.Text);
workout.Exercise3Reps = Convert.ToInt32(Exercise3Reps.Text);
workout.Exercise4Sets = Convert.ToInt32(Exercise4Sets.Text);
workout.Exercise4Reps = Convert.ToInt32(Exercise4Reps.Text);
workout.Exercise5Sets = Convert.ToInt32(Exercise5Sets.Text);
workout.Exercise5Reps = Convert.ToInt32(Exercise5Reps.Text);
//Call the Business Logic method to add workout
bll.AddWorkout(workout);
//Return to the Workouts list after adding the trainee to database
Response.Redirect("~/Workouts.aspx");
}
}
// GET: Workouts/Create
public async Task <ActionResult> Create()
{
var user = await userManager.FindByIdAsync(User.Identity.GetUserId());
if (user == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.Unauthorized));
}
var exerciseTypeOptions = exerciseTypeService.GetAll(user.Id).ToList();
if (exerciseTypeOptions.Count == 0)
{
return(Redirect("/Exercises/All"));
}
ViewBag.ExerciseTypeOptions = exerciseTypeOptions;
var workoutVM = new WorkoutViewModel();
workoutVM.WorkoutDate = DateTime.Today;
workoutVM.Exercises.Add(new ExerciseViewModel());
workoutVM.Exercises.First().Sets.Add(new SetViewModel());
workoutVM.Exercises.First().Sets.Add(new SetViewModel());
workoutVM.Exercises.First().Sets.Add(new SetViewModel());
return(View(workoutVM));
}
/// <summary>
/// Method for Load event to load values into the form for edit
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
protected void Page_Load(object sender, EventArgs e)
{
//Only load the values if the request is not a PostBack
if (!IsPostBack)
{
WorkoutViewModel workout = bll.GetWorkoutById(Convert.ToInt32(Request.QueryString["WorkoutID"]));
WorkoutName.Text = workout.WorkoutName;
Exercise1.Text = workout.Exercise1;
Exercise1Sets.Text = workout.Exercise1Sets.ToString();
Exercise1Reps.Text = workout.Exercise1Reps.ToString();
Exercise2.Text = workout.Exercise2;
Exercise2Sets.Text = workout.Exercise2Sets.ToString();
Exercise2Reps.Text = workout.Exercise2Reps.ToString();
Exercise3.Text = workout.Exercise3;
Exercise3Sets.Text = workout.Exercise3Sets.ToString();
Exercise3Reps.Text = workout.Exercise3Reps.ToString();
Exercise4.Text = workout.Exercise4;
Exercise4Sets.Text = workout.Exercise4Sets.ToString();
Exercise4Reps.Text = workout.Exercise4Reps.ToString();
Exercise5.Text = workout.Exercise5;
Exercise5Sets.Text = workout.Exercise5Sets.ToString();
Exercise5Reps.Text = workout.Exercise5Reps.ToString();
}
}
public async Task <IActionResult> Create([Bind("WorkoutId,WorkoutName,WorkoutTypeId")] WorkoutViewModel model,
string[] selectedExercises)
{
var workout = _mapper.Map <WorkoutViewModel, Workout>(model);
if (selectedExercises != null)
{
workout.ExerciseAssigments = new List <ExerciseAssigment>();
foreach (var exercise in selectedExercises)
{
var exerciseToAdd =
new ExerciseAssigment()
{
WorkoutId = workout.WorkoutId, ExerciseId = int.Parse(exercise)
};
workout.ExerciseAssigments.Add(exerciseToAdd);
}
}
if (ModelState.IsValid)
{
_unitOfWork.WorkoutRepository.Add(workout);
await _unitOfWork.WorkoutRepository.SaveAsync();
return(RedirectToAction(nameof(Index)));
}
PopulateAssignedExerciseData(workout);
ViewData["WorkoutTypeId"] =
new SelectList(_unitOfWork.WorkoutTypeRepository.GetAll(), "WorkoutTypeId", "WorkoutTypeName", workout.WorkoutTypeId);
var workoutVm = _mapper.Map <Workout, WorkoutViewModel>(workout);
return(View(workoutVm));
}
/// <summary>
/// Edit an existing interval
/// </summary>
/// <param name="workoutViewModel"></param>
/// <param name="intervalViewModel"></param>
public IntervalPage(WorkoutViewModel workoutViewModel, IntervalViewModel intervalViewModel)
{
Init(workoutViewModel);
newItem = false;
_intensity = intervalViewModel.Intensity;
switch (intervalViewModel.Type)
{
case IntervalType.DURATION:
DurationInterval(intervalViewModel);
break;
case IntervalType.DISTANCE:
DistanceInterval(intervalViewModel);
break;
case IntervalType.GOTO:
GoToInterval(intervalViewModel);
break;
default:
throw new NotImplementedException("default");
}
}
//Get Workout By Id, returns one instance of WorkoutViewModel
//Very similar to GetWorkouts() method above
public WorkoutViewModel GetWorkoutById(int id)
{
WorkoutViewModel workout = new WorkoutViewModel();
string sqlQuery = "Select * from Workout where WorkoutId=@ID";
using (SqlConnection con = new SqlConnection(_connectionString))
using (SqlCommand cmd = new SqlCommand(sqlQuery, con))
{
con.Open();
cmd.Parameters.Add("@ID", SqlDbType.Int).Value = id;
using (SqlDataReader reader = cmd.ExecuteReader())
{
while (reader.Read())
{
workout.WorkoutID = Convert.ToInt32(reader["WorkoutID"]);
workout.WorkoutName = reader["WorkoutName"].ToString();
workout.Exercise1 = reader["Exercise1"].ToString();
workout.Exercise1Reps = Convert.ToInt32(reader["Exercise1Reps"]);
workout.Exercise1Sets = Convert.ToInt32(reader["Exercise1Sets"]);
workout.Exercise2 = reader["Exercise2"].ToString();
workout.Exercise2Reps = Convert.ToInt32(reader["Exercise2Reps"]);
workout.Exercise2Sets = Convert.ToInt32(reader["Exercise2Sets"]);
workout.Exercise3 = reader["Exercise3"].ToString();
workout.Exercise3Reps = Convert.ToInt32(reader["Exercise3Reps"]);
workout.Exercise3Sets = Convert.ToInt32(reader["Exercise3Sets"]);
workout.Exercise4 = reader["Exercise4"].ToString();
workout.Exercise4Reps = Convert.ToInt32(reader["Exercise4Reps"]);
workout.Exercise4Sets = Convert.ToInt32(reader["Exercise4Sets"]);
workout.Exercise5 = reader["Exercise5"].ToString();
workout.Exercise5Reps = Convert.ToInt32(reader["Exercise5Reps"]);
workout.Exercise5Sets = Convert.ToInt32(reader["Exercise5Sets"]);
}
}
}
return workout;
}
//
// GET: /Health/
public ViewResult Index()
{
var exercises = db.Exercises.ToList();
var workouts = wdb.WorkoutDescription.ToList();
var exviewmodels = new List <ExerciseViewModel>();
var wviewmodels = new List <WorkoutViewModel>();
var TableData = new ExerciseViewModel[7, 24];
foreach (var exercise in exercises)
{
var a = new ExerciseViewModel();
a.Day = exercise.Day;
a.Time = exercise.Time;
a.Exercise = exercise.Exercise;
a.ID = exercise.ID;
a.DayName = new DatePretty().Prettify(a.Day);
exviewmodels.Add(a);
TableData[a.Day, a.Time] = a;
}
foreach (var workout in workouts)
{
var a = new WorkoutViewModel();
a.ID = workout.ID;
a.Name = workout.Name;
a.Description = workout.Description;
wviewmodels.Add(a);
}
var VMIndex = new ExerciseViewModelIndex();
VMIndex.exercises = exviewmodels;
VMIndex.workouts = wviewmodels;
VMIndex.TableData = TableData;
return(View(VMIndex));
}
protected void WorkoutEditButton_Click(object sender, EventArgs e)
{
//Check to see if all ValidationControls are valid
if (Page.IsValid)
{
//Create new empty ViewModel to pass in the new values
WorkoutViewModel workout = new WorkoutViewModel();
//Use the same query string to fill the ID
workout.WorkoutID = Convert.ToInt32(Request.QueryString["WorkoutID"]);
workout.WorkoutName = WorkoutName.Text;
workout.Exercise1 = Exercise1.Text;
workout.Exercise1Sets = Convert.ToInt32(Exercise1Sets.Text);
workout.Exercise1Reps = Convert.ToInt32(Exercise1Reps.Text);
workout.Exercise2 = Exercise2.Text;
workout.Exercise2Sets = Convert.ToInt32(Exercise2Sets.Text);
workout.Exercise2Reps = Convert.ToInt32(Exercise2Reps.Text);
workout.Exercise3 = Exercise3.Text;
workout.Exercise3Sets = Convert.ToInt32(Exercise3Sets.Text);
workout.Exercise3Reps = Convert.ToInt32(Exercise3Reps.Text);
workout.Exercise4 = Exercise4.Text;
workout.Exercise4Sets = Convert.ToInt32(Exercise4Sets.Text);
workout.Exercise4Reps = Convert.ToInt32(Exercise4Reps.Text);
workout.Exercise5 = Exercise5.Text;
workout.Exercise5Sets = Convert.ToInt32(Exercise5Sets.Text);
workout.Exercise5Reps = Convert.ToInt32(Exercise5Reps.Text);
//Call the EditWorkout() method passing in the new values
bll.EditWorkout(workout);
//Redirect to the Trainees.aspx page
Response.Redirect("~/Workouts.aspx");
}
}
//Add Workout using "INSERT" Sql Query depending on the values, very similar to EditWorkout
//method above
public int AddWorkout(WorkoutViewModel add)
{
string sqlQuery = "INSERT INTO Workout (WorkoutName, Exercise1, Exercise1Reps, Exercise1Sets, Exercise2, Exercise2Reps, Exercise2Sets, Exercise3, Exercise3Reps, Exercise3Sets, Exercise4, Exercise4Reps, Exercise4Sets, Exercise5, Exercise5Reps, Exercise5Sets) VALUES (@WorkoutName, @Exercise1, @Exercise1Reps, @Exercise1Sets, @Exercise2, @Exercise2Reps, @Exercise2Sets, @Exercise3, @Exercise3Reps, @Exercise3Sets, @Exercise4, @Exercise4Reps, @Exercise4Sets, @Exercise5, @Exercise5Reps, @Exercise5Sets) ";
using (SqlConnection con = new SqlConnection(_connectionString))
using (SqlCommand cmd = new SqlCommand(sqlQuery, con))
{
con.Open();
cmd.Parameters.Add("@ID", SqlDbType.Int).Value = add.WorkoutID;
cmd.Parameters.Add("@WorkoutName", SqlDbType.VarChar).Value = add.WorkoutName;
cmd.Parameters.Add("@Exercise1", SqlDbType.VarChar).Value = add.Exercise1;
cmd.Parameters.Add("@Exercise1Reps", SqlDbType.Int).Value = add.Exercise1Reps;
cmd.Parameters.Add("@Exercise1Sets", SqlDbType.Int).Value = add.Exercise1Sets;
cmd.Parameters.Add("@Exercise2", SqlDbType.VarChar).Value = add.Exercise2;
cmd.Parameters.Add("@Exercise2Reps", SqlDbType.Int).Value = add.Exercise2Reps;
cmd.Parameters.Add("@Exercise2Sets", SqlDbType.Int).Value = add.Exercise2Sets;
cmd.Parameters.Add("@Exercise3", SqlDbType.VarChar).Value = add.Exercise3;
cmd.Parameters.Add("@Exercise3Reps", SqlDbType.Int).Value = add.Exercise3Reps;
cmd.Parameters.Add("@Exercise3Sets", SqlDbType.Int).Value = add.Exercise3Sets;
cmd.Parameters.Add("@Exercise4", SqlDbType.VarChar).Value = add.Exercise4;
cmd.Parameters.Add("@Exercise4Reps", SqlDbType.Int).Value = add.Exercise4Reps;
cmd.Parameters.Add("@Exercise4Sets", SqlDbType.Int).Value = add.Exercise4Sets;
cmd.Parameters.Add("@Exercise5", SqlDbType.VarChar).Value = add.Exercise5;
cmd.Parameters.Add("@Exercise5Reps", SqlDbType.Int).Value = add.Exercise5Reps;
cmd.Parameters.Add("@Exercise5Sets", SqlDbType.Int).Value = add.Exercise5Sets;
return(cmd.ExecuteNonQuery());
}
}
//Edits Workout using "UPDATE" Sql Query passing in values to edit depending on the TraineeID
public int EditWorkout(WorkoutViewModel edit)
{
string sqlQuery = "UPDATE Workout Set WorkoutName=@WorkoutName, Exercise1=@Exercise1, Exercise1Reps=@Exercise1Reps, Exercise1Sets=@Exercise1Sets, Exercise2=@Exercise2, Exercise2Reps=@Exercise2Reps, Exercise2Sets=@Exercise2Sets, Exercise3=@Exercise3, Exercise3Reps=@Exercise3Reps, Exercise3Sets=@Exercise3Sets, " +
"Exercise4=@Exercise4, Exercise4Reps=@Exercise4Reps, Exercise4Sets=@Exercise4Sets, Exercise5=@Exercise5, Exercise5Reps=@Exercise5Reps, Exercise5Sets=@Exercise5Sets";
//No need to use SqlDataReader here since we are just using the sql Query to persist to database
using (SqlConnection con = new SqlConnection(_connectionString))
using (SqlCommand cmd = new SqlCommand(sqlQuery, con))
{
con.Open();
cmd.Parameters.Add("@ID", SqlDbType.Int).Value = edit.WorkoutID;
cmd.Parameters.Add("@WorkoutName", SqlDbType.VarChar).Value = edit.WorkoutName;
cmd.Parameters.Add("@Exercise1", SqlDbType.VarChar).Value = edit.Exercise1;
cmd.Parameters.Add("@Exercise1Reps", SqlDbType.Int).Value = edit.Exercise1Reps;
cmd.Parameters.Add("@Exercise1Sets", SqlDbType.Int).Value = edit.Exercise1Sets;
cmd.Parameters.Add("@Exercise2", SqlDbType.VarChar).Value = edit.Exercise2;
cmd.Parameters.Add("@Exercise2Reps", SqlDbType.Int).Value = edit.Exercise2Reps;
cmd.Parameters.Add("@Exercise2Sets", SqlDbType.Int).Value = edit.Exercise2Sets;
cmd.Parameters.Add("@Exercise3", SqlDbType.VarChar).Value = edit.Exercise3;
cmd.Parameters.Add("@Exercise3Reps", SqlDbType.Int).Value = edit.Exercise3Reps;
cmd.Parameters.Add("@Exercise3Sets", SqlDbType.Int).Value = edit.Exercise3Sets;
cmd.Parameters.Add("@Exercise4", SqlDbType.VarChar).Value = edit.Exercise4;
cmd.Parameters.Add("@Exercise4Reps", SqlDbType.Int).Value = edit.Exercise4Reps;
cmd.Parameters.Add("@Exercise4Sets", SqlDbType.Int).Value = edit.Exercise4Sets;
cmd.Parameters.Add("@Exercise5", SqlDbType.VarChar).Value = edit.Exercise5;
cmd.Parameters.Add("@Exercise5Reps", SqlDbType.Int).Value = edit.Exercise5Reps;
cmd.Parameters.Add("@Exercise5Sets", SqlDbType.Int).Value = edit.Exercise5Sets;
return(cmd.ExecuteNonQuery());
}
}
private WorkoutViewModel Map(Workout entity)
{
var viewModel = new WorkoutViewModel();
viewModel.Id = entity.Id;
viewModel.Name = entity.Name;
viewModel.Length = entity.Length;
viewModel.AvgSpeed = entity.AvgSpeed;
viewModel.StartDateTime = entity.StartDateTime;
viewModel.ElapsedHours = entity.ElapsedHours;
viewModel.ElapsedMinutes = entity.ElapsedMinutes;
viewModel.ElapsedSeconds = entity.ElapsedSeconds;
viewModel.RaceTypeId = entity.RaceType.Id;
foreach (var gpsCoord in entity.GpsCoords)
{
viewModel.GpsCoords.Add(new GpsCoordViewModel
{
Elevation = gpsCoord.Elevation,
Latitude = gpsCoord.Latitude,
Longitude = gpsCoord.Longitude,
Timestamp = gpsCoord.TimeStamp
});
}
return(viewModel);
}
protected void Page_Load(object sender, EventArgs e)
{
TraineeViewModel trainee = tbll.GetTraineeById(Convert.ToInt32(Request.QueryString["TraineeID"]));
if (!IsPostBack)
{
if (trainee.WorkoutID == 0)
{
NoWorkout.Text = "THERE IS NO WORKOUT ASSIGNED TO: \r\n" + trainee.FirstName + " " + trainee.LastName;
}
else
{
WorkoutBLL wbll = new WorkoutBLL(ConfigurationManager.ConnectionStrings["MySwoleMateConnectionString"].ToString());
WorkoutViewModel workout = wbll.GetWorkoutById(Convert.ToInt32(trainee.WorkoutID));
NoWorkout.Text = trainee.FirstName + " " + trainee.LastName;
WorkoutName.Text = workout.WorkoutName;
DisplayExercise1.Text = workout.DisplayExercise1;
DisplayExercise2.Text = workout.DisplayExercise2;
DisplayExercise3.Text = workout.DisplayExercise3;
DisplayExercise4.Text = workout.DisplayExercise4;
DisplayExercise5.Text = workout.DisplayExercise5;
}
}
}
public ActionResult Overview(int id, string name)
{
Sets Set = new Sets();
var workouts = _context.Workoutss.SingleOrDefault(w => w.Id == id);
var sets = _context.Setss.ToList();
var execises = _context.Execisess.ToList();
WorkoutViewModel viewModel = new WorkoutViewModel();
viewModel.Workout = workouts;
viewModel.Sets = sets;
viewModel.Set = Set;
viewModel.Execises = execises;
if (workouts == null)
{
return(HttpNotFound());
}
if (User.IsInRole("CanManageAdmin"))
{
return(View(viewModel));
}
else
{
return(View("OverviewReadOnly", viewModel));
}
}
private WorkoutViewModel MapWorkoutDTO(WorkoutDTO model)
{
var exercises = new List<ExerciseViewModel>();
foreach (var exercise in model.Exercises)
{
exercises.Add(MapExercise(exercise));
}
var viewModel = new WorkoutViewModel
{
Id = model.Id,
WorkoutDate = model.WorkoutDate,
Exercises = exercises,
TotalWeight = String.Format("{0:0.##}", Math.Round(model.TotalWeight, 2))
};
return viewModel;
}
// GET: Workouts/Create
public async Task<ActionResult> Create()
{
var user = await userManager.FindByIdAsync(User.Identity.GetUserId());
if (user == null)
{
return new HttpStatusCodeResult(HttpStatusCode.Unauthorized);
}
var exerciseTypeOptions = exerciseTypeService.GetAll(user.Id).ToList();
if (exerciseTypeOptions.Count == 0)
{
return Redirect("/Exercises/All");
}
ViewBag.ExerciseTypeOptions = exerciseTypeOptions;
var workoutVM = new WorkoutViewModel();
workoutVM.WorkoutDate = DateTime.Today;
workoutVM.Exercises.Add(new ExerciseViewModel());
workoutVM.Exercises.First().Sets.Add(new SetViewModel());
workoutVM.Exercises.First().Sets.Add(new SetViewModel());
workoutVM.Exercises.First().Sets.Add(new SetViewModel());
return View(workoutVM);
}
private Workout MapWorkoutViewModel(WorkoutViewModel model)
{
var exercises = new List<Exercise>();
foreach (var exercise in model.Exercises)
{
exercises.Add(MapExerciseViewModel(exercise));
}
var workout = new Workout
{
Id = model.Id,
WorkoutDate = model.WorkoutDate,
Exercises = exercises
};
return workout;
}
public ActionResult AddExerciseEdit(int id = 1)
{
var exerciseTypeOptions = GetExerciseTypeOptions();
if (exerciseTypeOptions.Count == 0)
{
return Redirect("/Exercises/All");
}
ViewBag.ExerciseTypeOptions = exerciseTypeOptions;
var workoutVM = new WorkoutViewModel();
workoutVM.Exercises.Add(new ExerciseViewModel());
id = (id < 1) ? 1 : id;
for (int i = 0; i < id; i++)
{
workoutVM.Exercises.First().Sets.Add(new SetViewModel());
}
return View(workoutVM);
}
public async Task<ActionResult> Edit(WorkoutViewModel model)
{
var user = await userManager.FindByIdAsync(User.Identity.GetUserId());
if (user == null)
{
return new HttpStatusCodeResult(HttpStatusCode.Unauthorized);
}
var exerciseTypeOptions = exerciseTypeService.GetAll(user.Id).ToList();
if (exerciseTypeOptions.Count == 0)
{
return Redirect("/Exercises/All");
}
ViewBag.ExerciseTypeOptions = exerciseTypeOptions;
if (ModelState.IsValid)
{
var workout = MapWorkoutViewModel(model);
var oldWorkout = workoutService.Get(workout.Id);
if (oldWorkout == null ||
oldWorkout.ApplicationUser.Id != user.Id)
{
return View(model);
}
if (workout.WorkoutDate != oldWorkout.WorkoutDate)
{
var sameDateWorkout = workoutService.Find(w =>
w.ApplicationUser.Id == user.Id &&
w.WorkoutDate == workout.WorkoutDate).ToList();
if (sameDateWorkout.Count != 0)
{
ViewBag.Status = "A workout with such date already exists";
return View(model);
}
}
foreach (var exercise in workout.Exercises)
{
exercise.ExerciseType = exerciseTypeService.Get(exercise.ExerciseType.Id);
}
workout.ApplicationUser = user;
workoutService.Update(workout);
return Redirect("/Workouts/All");
}
return View(model);
}
