public TrainingTypeDTO getById(int Id)
{
TrainingTypeDTO trainingTypeDTO;
string query =
"SELECT * FROM training_type gt WHERE gt.id=@id ";
using (SqlConnection connection = EstablishingConnection.GetConnection())
{
connection.Open();
using (SqlCommand command = new SqlCommand(query, connection))
{
command.Parameters.AddWithValue("@id", Id);
SqlDataReader reader = command.ExecuteReader();
trainingTypeDTO = new TrainingTypeDTO();
while (reader.Read())
{
TrainingTypeDTO newTrainingTypeDTO = new TrainingTypeDTO()
{
Id = (int)reader["id"],
Name = (string)reader["name"]
};
trainingTypeDTO = newTrainingTypeDTO;
}
}
connection.Close();
}
return(trainingTypeDTO);
}
public void Update()
{
// Arrange
var updateTrainingType = new TrainingTypeDTO
{
Description = string.Empty,
TypeTraining = "Test CrossFit",
Id = 2
};
_mock.Setup(s => s.Update(It.IsAny <TrainingTypeDTO>())).Callback <TrainingTypeDTO>(updateValue =>
{
updateValue.ModifiedDate = DateTime.Now;
var trainingTypeIndex = _trainingTypes.FindIndex(tt => tt.Id == updateValue.Id);
_trainingTypes[trainingTypeIndex] = updateValue;
});
// Act
var result = _trainingTypeService.Update(updateTrainingType);
// Assert
Assert.IsNotNull(result);
Assert.IsInstanceOfType(result, typeof(IOperationResult));
Assert.IsTrue(result.Succeed);
Assert.IsTrue(result.ResultItemId > 0);
Assert.AreEqual(_trainingTypes.Find(tt => tt.Id == updateTrainingType.Id).TypeTraining, updateTrainingType.TypeTraining);
}
public List <TrainingTypeDTO> GetAll()
{
List <TrainingTypeDTO> trainingTypes;
using (SqlConnection connection = EstablishingConnection.GetConnection())
{
connection.Open();
using (SqlCommand command = new SqlCommand("select * from training_type", connection))
{
SqlDataReader reader = command.ExecuteReader();
trainingTypes = new List <TrainingTypeDTO>();
while (reader.Read())
{
TrainingTypeDTO trainingType = new TrainingTypeDTO
{
Id = (int)reader["id"],
Name = (string)reader["name"],
};
trainingTypes.Add(trainingType);
}
}
return(trainingTypes);
}
}
public TrainingDTO(Guid trainingID, Guid userID, DateTime date, TrainingTypeDTO trainingTypeDTO)
{
TrainingID = trainingID;
UserID = userID;
Date = date;
TrainingType = trainingTypeDTO;
}
public void Create()
{
// Arrange
var countTrainingTypes = _trainingTypes.Count;
var newTrainingType = new TrainingTypeDTO
{
Description = string.Empty,
TypeTraining = "Test Training Type"
};
_mock.Setup(s => s.Create(It.IsAny <TrainingTypeDTO>())).Returns <TrainingTypeDTO>(newItem =>
{
newItem.Id = _trainingTypes.Count + 1;
newItem.CreatedDate = DateTime.Now;
newItem.ModifiedDate = DateTime.Now;
_trainingTypes.Add(newItem);
return(newItem.Id);
});
// Act
var result = _trainingTypeService.Create(newTrainingType);
// Assert
Assert.IsNotNull(result);
Assert.IsInstanceOfType(result, typeof(IOperationResult));
Assert.AreEqual(countTrainingTypes + 1, _trainingTypes.Count);
Assert.IsTrue(result.Succeed);
Assert.IsTrue(result.ResultItemId > 0);
}
public List <TrainingDTO> GetUserTrainings(string userID)
{
List <TrainingDTO> trainings = new List <TrainingDTO>();
using (SqlConnection connection = new SqlConnection(GetConnectionString()))
{
SqlCommand cmd = new SqlCommand("SELECT * FROM Trainings WHERE UserID = @UserID ORDER BY Date DESC", connection);
cmd.Parameters.AddWithValue("@UserID", userID);
connection.Open();
using (SqlDataReader reader = cmd.ExecuteReader())
{
while (reader.Read())
{
Guid trainingID = Guid.Parse(reader["ID"].ToString());
DateTime date = (DateTime)reader["Date"];
TrainingTypeDTO trainingType = (TrainingTypeDTO)Enum.Parse(typeof(TrainingTypeDTO), reader["TrainingType"].ToString());
TrainingDTO training = new TrainingDTO(trainingID, Guid.Parse(userID), date, trainingType);
trainings.Add(training);
}
}
}
return(trainings);
}
public CardioTrainingDTO GetCardioTraining(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;
ExerciseDTO exercise = new ExerciseDTO();
decimal distance = 0;
TrainingTypeDTO trainingType = TrainingTypeDTO.Cardio;
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());
}
}
SqlCommand cmdCardioTraining = new SqlCommand("SELECT * FROM CardioTrainings WHERE TrainingID = @TrainingID", connection);
cmdCardioTraining.Parameters.AddWithValue("@TrainingID", trainingID);
using (SqlDataReader cardioReader = cmdCardioTraining.ExecuteReader())
{
while (cardioReader.Read())
{
distance = Convert.ToDecimal(cardioReader["Distance"].ToString());
exercise = GetExerciseDTO(cardioReader["ExerciseID"].ToString());
long ticks = Convert.ToInt64(cardioReader["Time"].ToString());
TimeSpan time = new TimeSpan(ticks);
CardioTrainingDTO cardioTrainingDTO = new CardioTrainingDTO(exercise, distance, time, Guid.Parse(trainingID), userID, date, trainingType);
return(cardioTrainingDTO);
}
}
return(null);
}
}
public UserDTO GetUser(string username)
{
using (SqlConnection connection = new SqlConnection(GetConnectionString()))
{
SqlCommand cmdUser = new SqlCommand("SELECT * FROM Users WHERE Name = @Name", connection);
cmdUser.Parameters.AddWithValue("@Name", username);
Guid userID = Guid.Empty;
string password = null;
string name = null;
connection.Open();
using (SqlDataReader reader = cmdUser.ExecuteReader())
{
while (reader.Read())
{
userID = Guid.Parse(reader["UserID"].ToString());
password = reader["Password"].ToString();
name = reader["Name"].ToString();
}
}
List <TrainingDTO> trainingDTOs = new List <TrainingDTO>();
SqlCommand cmdTrainings = new SqlCommand("SELECT * FROM Trainings WHERE UserID = @UserID ORDER BY Date DESC", connection);
cmdTrainings.Parameters.AddWithValue("@UserID", username);
using (SqlDataReader reader = cmdTrainings.ExecuteReader())
{
while (reader.Read())
{
Guid trainingID = Guid.Parse(reader["ID"].ToString());
DateTime date = (DateTime)reader["Date"];
TrainingTypeDTO trainingType = (TrainingTypeDTO)Enum.Parse(typeof(TrainingTypeDTO), reader["TrainingType"].ToString());
TrainingDTO training = new TrainingDTO(trainingID, Guid.Parse(username), date, trainingType);
trainingDTOs.Add(training);
}
}
UserDTO userDTO = new UserDTO(name, userID, password, trainingDTOs, null);
return(userDTO);
}
}
public TrainingDTO GetTraining(string trainingID)
{
using (SqlConnection connection = new SqlConnection(GetConnectionString()))
{
SqlCommand cmdTraining = new SqlCommand("SELECT * FROM Trainings WHERE ID = @TrainingID", connection);
cmdTraining.Parameters.AddWithValue("@TrainingID", trainingID);
connection.Open();
TrainingDTO trainingDTO = new TrainingDTO();
using (SqlDataReader reader = cmdTraining.ExecuteReader())
{
while (reader.Read())
{
Guid userID = Guid.Parse(reader["UserID"].ToString());
DateTime date = (DateTime)reader["Date"];
TrainingTypeDTO trainingType = (TrainingTypeDTO)Enum.Parse(typeof(TrainingTypeDTO), reader["TrainingType"].ToString());
trainingDTO = new TrainingDTO(Guid.Parse(trainingID), userID, date, trainingType);
}
}
connection.Close();
return(trainingDTO);
}
}
public WeightTrainingDTO(List <RoundDTO> rounds, Guid userID, DateTime date, TrainingTypeDTO trainingTypeDTO) : base(userID, date, trainingTypeDTO)
{
this.rounds = rounds;
}
public CardioTrainingDTO(ExerciseDTO exercise, decimal distance, TimeSpan time, Guid userID, DateTime date, TrainingTypeDTO trainingTypeDTO) : base(userID, date, trainingTypeDTO)
{
Exercise = exercise;
Distance = distance;
Time = time;
}
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);
}
}
}
