public WeightTrainingDTO GetWeightTraining(string trainingID)
{
ITrainingDAL trainingDAL = TrainingDALFactory.GetTrainingDAL();
WeightTrainingDTO training = trainingDAL.GetWeightTraining(trainingID);
return(training);
}
public void AddWeightTraining()
{
//arrange
IUser user = UserFactory.GetUser();
IUserCollection userCollection = UserCollectionFactory.GetUserCollection();
ITrainingDAL dal = TrainingDALFactory.GetTrainingDAL();
ExerciseDTO deadlift = userCollection.GetExercise("Deadlift");
ExerciseDTO squat = userCollection.GetExercise("Squat");
ExerciseDTO pullup = userCollection.GetExercise("Pullup");
List <SetDTO> deadliftSets = new List <SetDTO>
{
new SetDTO(80, 0),
new SetDTO(85, 1),
new SetDTO(90, 2)
};
List <SetDTO> squatSets = new List <SetDTO>
{
new SetDTO(50, 0),
new SetDTO(55, 1),
new SetDTO(60, 2)
};
List <SetDTO> pullupSets = new List <SetDTO>
{
new SetDTO(7, 0),
new SetDTO(7, 1),
new SetDTO(7, 2)
};
List <RoundDTO> rounds = new List <RoundDTO>
{
new RoundDTO(deadlift, deadlift.ExerciseID, deadliftSets),
new RoundDTO(squat, squat.ExerciseID, squatSets),
new RoundDTO(pullup, pullup.ExerciseID, pullupSets)
};
UserDTO userDTO = new UserDTO("TempAccountWeightTraining", Guid.NewGuid(), "TempPassword", null, null);
IUserCollectionDAL userCollectionDAL = UserCollectionDALFactory.GetUserCollectionDAL();
userCollectionDAL.AddUser(userDTO);
WeightTrainingDTO weightTrainingDTO = new WeightTrainingDTO(rounds, userDTO.UserID, DateTime.Now, TrainingTypeDTO.Strength);
//act
user.AddStrengthTraining(weightTrainingDTO);
//assert
Guid trainingID = dal.GetUserTrainings(userDTO.UserID.ToString())[0].TrainingID;
WeightTrainingDTO trainingFromDB = dal.GetWeightTraining(trainingID.ToString());
Assert.AreEqual(userDTO.UserID, trainingFromDB.UserID);
Assert.AreEqual(weightTrainingDTO.Date.ToLongDateString(), trainingFromDB.Date.ToLongDateString());
Assert.AreEqual(TrainingTypeDTO.Strength, trainingFromDB.TrainingType);
}
private WeightTrainingDTO ConvertWeightTraining(WeightTraining training)
{
List <RoundDTO> roundDTOs = new List <RoundDTO>();
foreach (var round in training.GetRounds())
{
roundDTOs.Add(ConvertRound(round));
}
WeightTrainingDTO trainingDTO = new WeightTrainingDTO(roundDTOs, training.TrainingID, training.UserID, training.Date, (TrainingTypeDTO)training.TrainingType);
return(trainingDTO);
}
private WeightTraining ConvertWeightTrainingDTO(WeightTrainingDTO trainingDTO)
{
List <Round> rounds = new List <Round>();
foreach (var roundDTO in trainingDTO.GetRounds())
{
rounds.Add(ConvertRoundDTO(roundDTO));
}
WeightTraining training = new WeightTraining(rounds, trainingDTO.TrainingID, trainingDTO.UserID, trainingDTO.Date, (TrainingType)trainingDTO.TrainingType);
return(training);
}
public void AddWeightTraining(WeightTrainingDTO trainingDTO)
{
using (SqlConnection connection = new SqlConnection(GetConnectionString()))
{
SqlCommand cmd = new SqlCommand("" +
"INSERT INTO Trainings " +
"VALUES(@TrainingID, @UserID, @Date, @TrainingType) " +
"INSERT INTO WeightTrainings " +
"VALUES(@TrainingID)", connection);
cmd.Parameters.AddWithValue("@TrainingID", trainingDTO.TrainingID);
cmd.Parameters.AddWithValue("@UserID", trainingDTO.UserID);
cmd.Parameters.AddWithValue("@Date", trainingDTO.Date);
cmd.Parameters.AddWithValue("@TrainingType", TrainingTypeDTO.Strength);
connection.Open();
cmd.ExecuteNonQuery();
connection.Close();
}
foreach (var round in trainingDTO.GetRounds())
{
using (SqlConnection connection = new SqlConnection(GetConnectionString()))
{
SqlCommand cmdRound = new SqlCommand("INSERT INTO Rounds VALUES(@RoundID, @ExerciseID, @TrainingID)", connection);
cmdRound.Parameters.AddWithValue("@RoundID", round.RoundID);
cmdRound.Parameters.AddWithValue("@ExerciseID", round.ExerciseID);
cmdRound.Parameters.AddWithValue("@TrainingID", trainingDTO.TrainingID);
connection.Open();
cmdRound.ExecuteNonQuery();
connection.Close();
foreach (var set in round.GetSets())
{
SqlCommand cmdSet = new SqlCommand("INSERT INTO Sets VALUES(@SetID, @RoundID, @SetOrder, @Weight)", connection);
cmdSet.Parameters.AddWithValue("@SetID", set.SetID);
cmdSet.Parameters.AddWithValue("@RoundID", round.RoundID);
cmdSet.Parameters.AddWithValue("@SetOrder", set.SetOrder);
cmdSet.Parameters.AddWithValue("@Weight", set.Weight);
connection.Open();
cmdSet.ExecuteNonQuery();
connection.Close();
}
}
}
}
public IActionResult AddStrengthTraining(TrainingViewModel trainingViewModel)
{
try
{
foreach (var round in trainingViewModel.Rounds)
{
if (String.IsNullOrEmpty(round.Exercise.Name))
{
ModelState.AddModelError("Rounds", "Fill in the exercise names");
return(View(trainingViewModel));
}
foreach (var set in round.Sets)
{
if (set.Weight == 0)
{
ModelState.AddModelError("Rounds", "Please fill in all the weights");
return(View(trainingViewModel));
}
}
}
List <RoundDTO> rounds = new List <RoundDTO>();
foreach (var roundViewModel in trainingViewModel.Rounds)
{
rounds.Add(ConvertRoundVM(roundViewModel));
}
WeightTrainingDTO weightTraining = new WeightTrainingDTO(rounds, Guid.Parse(User.FindFirst("Id").Value), new DateTime(2021, 1, 15), TrainingTypeDTO.Strength);
UserCollection userCollection = new UserCollection();
User user = ConvertUserDTO(userCollection.GetUser(User.Identity.Name));
user.AddStrengthTraining(weightTraining);
TempData["JustAddedTraining"] = true;
return(LocalRedirect("/Home/Index"));
}
catch
{
TempData["Error"] = true;
return(LocalRedirect("/Training/AddStrengthTraining"));
}
}
public void AddStrengthTraining(WeightTrainingDTO training)
{
ITrainingDAL dal = TrainingDALFactory.GetTrainingDAL();
Guid trainingID = Guid.NewGuid();
List <RoundDTO> rounds = new List <RoundDTO>();
foreach (var round in training.GetRounds())
{
Guid roundID = Guid.NewGuid();
List <SetDTO> sets = new List <SetDTO>();
foreach (var set in round.GetSets())
{
SetDTO setToAdd = new SetDTO(set.Weight, Guid.NewGuid(), set.SetOrder, roundID);
sets.Add(setToAdd);
}
RoundDTO roundToAdd = new RoundDTO(round.Exercise, roundID, trainingID, round.ExerciseID, sets);
rounds.Add(roundToAdd);
}
WeightTrainingDTO weightTrainingToAdd = new WeightTrainingDTO(rounds, trainingID, training.UserID, training.Date, training.TrainingType);
dal.AddWeightTraining(weightTrainingToAdd);
}
public IActionResult TrainingDetail(Guid id)
{
try
{
User user = new User();
TrainingViewModel trainingVM = ConvertTrainingDTO(user.GetTraining(id.ToString()));
if (trainingVM.TrainingType == TrainingType.Strength)
{
WeightTrainingDTO weightTrainingDTO = user.GetWeightTraining(id.ToString());
List <RoundViewModel> roundViewModels = new List <RoundViewModel>();
foreach (var roundDTO in weightTrainingDTO.GetRounds())
{
roundViewModels.Add(ConvertRoundDTO(roundDTO));
}
trainingVM.Rounds = roundViewModels;
}
else
{
CardioTrainingDTO cardioTrainingDTO = user.GetCardioTraining(id.ToString());
trainingVM.Exercise = ConvertExerciseDTOToVM(cardioTrainingDTO.Exercise);
trainingVM.Distance = Math.Round(cardioTrainingDTO.Distance, 2);
trainingVM.Minutes = cardioTrainingDTO.Time.Minutes;
trainingVM.Seconds = cardioTrainingDTO.Time.Seconds;
trainingVM.TrainingID = cardioTrainingDTO.TrainingID;
}
return(View(trainingVM));
}
catch
{
TempData["Error"] = true;
return(LocalRedirect("/Home/Index"));
}
}
public WeightTrainingDTO GetWeightTraining(string trainingID)
{
using (SqlConnection connection = new SqlConnection(GetConnectionString()))
{
SqlCommand cmdTraining = new SqlCommand("SELECT * FROM Trainings WHERE ID = @TrainingID", connection);
cmdTraining.Parameters.AddWithValue("@TrainingID", trainingID);
DateTime date = DateTime.MinValue;
Guid userID = Guid.Empty;
TrainingTypeDTO trainingType = TrainingTypeDTO.Strength;
connection.Open();
using (SqlDataReader reader = cmdTraining.ExecuteReader())
{
while (reader.Read())
{
date = Convert.ToDateTime(reader["Date"]);
userID = Guid.Parse(reader["UserID"].ToString());
trainingType = (TrainingTypeDTO)Enum.Parse(typeof(TrainingTypeDTO), reader["TrainingType"].ToString());
}
}
connection.Close();
SqlCommand cmdRound = new SqlCommand("SELECT * FROM Rounds WHERE TrainingID = @TrainingID", connection);
cmdRound.Parameters.AddWithValue("@TrainingID", trainingID);
List <RoundDTO> rounds = new List <RoundDTO>();
connection.Open();
using (SqlDataReader reader = cmdRound.ExecuteReader())
{
while (reader.Read())
{
Guid exerciseID = Guid.Parse(reader["ExerciseID"].ToString());
ExerciseDTO exercise = GetExerciseDTO(exerciseID.ToString());
Guid roundID = Guid.Parse(reader["ID"].ToString());
SqlCommand cmdSet = new SqlCommand("SELECT * FROM Sets WHERE RoundID = @RoundID ORDER BY SetOrder", connection);
cmdSet.Parameters.AddWithValue("@RoundID", roundID);
List <SetDTO> sets = new List <SetDTO>();
using (SqlDataReader setReader = cmdSet.ExecuteReader())
{
while (setReader.Read())
{
Guid setID = Guid.Parse(setReader["SetID"].ToString());
int setOrder = Convert.ToInt32(setReader["SetOrder"]);
double weight = Convert.ToInt32(setReader["Weight"]);
SetDTO setDTO = new SetDTO(weight, setID, setOrder, roundID);
sets.Add(setDTO);
}
}
RoundDTO roundDTO = new RoundDTO(exercise, roundID, Guid.Parse(trainingID), exerciseID, sets);
rounds.Add(roundDTO);
}
WeightTrainingDTO weightTrainingDTO = new WeightTrainingDTO(rounds, Guid.Parse(trainingID), userID, date, trainingType);
return(weightTrainingDTO);
}
}
}
