private async Task RemoveRecords(List <Models.Persistence.Workout> workouts)
{
WorkoutFactory workout = new WorkoutFactory();
await workout.RemoveWorkoutAndRelatedExercisesAndSets(_connection, workouts);
OnAppearing();
}
public void GIVEN_Bad_Reader_WHEN_Retrieving_Workouts_Summaries_THEN_Exception()
{
//Arrange
var badFactory = new WorkoutFactory(_invalidReader);
//Act
IEnumerable<Workout> actual = badFactory.GetSummaries();
}
public void GIVEN_Bad_Reader_WHEN_Retrieving_Workout_IDs_THEN_Exception()
{
//Arrange
var badFactory = new WorkoutFactory(_invalidReader);
//Act
var ids = badFactory.GetIDs();
}
public void GIVEN_Bad_Reader_WHEN_Retrieving_Workouts_Via_Get_THEN_Exception()
{
//Arrange
var badFactory = new WorkoutFactory(_invalidReader);
//Act
var workCopy = badFactory.GetWorkout(1);
}
public async Task ExerciseAlgorithm(string exercise1, string exercise2, Models.Persistence.Workout workout)
{
if (exercise1 != "I don't need help!" && exercise1 != "")
{
bool result = await WorkoutFactory.CheckExerciseHistory(_connection, exercise1);
var doExerciseRecordsExist = await WorkoutFactory.CreateExerciseSets(_connection, exercise1, workout);
DateTime date = doExerciseRecordsExist.ExerciseSetAssistantDate;
if (result)
{
if (doExerciseRecordsExist.Exist == false)
{
await DisplayAlert("No " + exercise1 + " History Found!", "Please complete sets of 12,10,8,6,4 repetitions for this exercise for the application to generate future workouts.", "Ok");
await WorkoutFactory.CreateEmptyExerciseSets(_connection, exercise1, workout, date);
}
}
else
{
await DisplayAlert("No " + exercise1 + " History Found!", "Please complete sets of 12,10,8,6,4 repetitions for this exercise for the application to generate future workouts.", "Ok");
await WorkoutFactory.CreateEmptyExerciseSets(_connection, exercise1, workout, date);
}
}
if (exercise2 != "I don't need help!" && exercise2 != "" && exercise2 != "None")
{
bool result = await WorkoutFactory.CheckExerciseHistory(_connection, exercise2);
var doExerciseRecordsExist = await WorkoutFactory.CreateExerciseSets(_connection, exercise2, workout);
DateTime date = doExerciseRecordsExist.ExerciseSetAssistantDate;
if (result)
{
if (doExerciseRecordsExist.Exist == false)
{
await DisplayAlert("No " + exercise1 + " history found!", "Please complete sets of 12,10,8,6,4 repetitions for this exercise for the application to generate future workouts.", "Ok");
await WorkoutFactory.CreateEmptyExerciseSets(_connection, exercise2, workout, date);
}
}
else
{
await DisplayAlert("No " + exercise2 + " history found!", "Please complete sets of 12,10,8,6,4 repetitions for this exercise for the application to generate future workouts.", "Ok");
await WorkoutFactory.CreateEmptyExerciseSets(_connection, exercise2, workout, date);
}
}
///////
}
public void GIVEN_Valid_Reader_WHEN_Retrieving_Workout_IDs_THEN_IDS_Retrieved()
{
//Arrange
var goodFactory = new WorkoutFactory(_validReader);
//Act
var ids = goodFactory.GetIDs();
//Assert
Assert.IsNotNull(ids);
Assert.AreNotEqual(ids.Count(), 0);
}
public void GIVEN_Valid_Reader_WHEN_Creating_WorkoutFactory_THEN_No_Exception()
{
var target = new WorkoutFactory(_validReader);
}
public List <WorkoutModel> GetAll(int userId)
{
return(WorkoutFactory.CreateWorkoutContainerDAL().GetAll(userId));
}
public void Delete(int id)
{
WorkoutFactory.CreateWorkoutContainerDAL().Delete(id);
}
public void GIVEN_Null_Reader_WHEN_Retrieving_Workouts_Summaries_THEN_Exception()
{
//TODO: Validate values in returned entity
var nullFactory = new WorkoutFactory(_nullXDocReader);
IEnumerable<Workout> actual = nullFactory.GetSummaries();
}
public void GIVEN_Null_Reader_WHEN_Creating_WorkoutFactory_THEN_Exception()
{
var target = new WorkoutFactory(null);
}
public void GIVEN_List_Of_IDs_WHEN_Retrieving_By_ID_THEN_Populated_Workout_Retrieved()
{
//Arrange
var converter = new WorkoutFactory(_validReader);
//Act
var ids = converter.GetIDs();
foreach (var id in ids)
{
var w = converter.GetWorkout(id);
Assert.IsNotNull(w);
Console.Out.WriteLine("{0} [{1}] Calories: {2} Distance: {3} Time: {4}", w.ID, w.Name, w.Calories, w.Distance, new TimeSpan(w.Duration));
if (w.Snapshots != null)
{
foreach (var ss in w.Snapshots)
{
Console.Out.WriteLine("{0} {1} {2} {3}", ss.DataType, ss.Interval, ss.IntervalType, ss.IntervalUnit);
if (ss.Intervals != null)
{
Console.Out.WriteLine("Num of Intervals: {0}", ss.Intervals.Count());
}
}
}
}
//Assert
Assert.IsNotNull(ids);
Assert.AreNotEqual(ids.Count(), 0);
}
public void GIVEN_Empty_Run_XDoc_WHEN_Retrieving_Workout_By_ID_THEN_Exception()
{
var badFactory = new WorkoutFactory(_emptyXDocReader);
var goodFactory = new WorkoutFactory(_validReader);
foreach (var id in goodFactory.GetIDs())
{
badFactory.GetWorkout(id);
}
}
public void GIVEN_Empty_Reader_WHEN_Retrieving_Workout_Summaries_THEN_No_Exception()
{
//Arrange
var emptyFactory = new WorkoutFactory(_emptyXDocReader);
//Act
IEnumerable<Workout> actual = emptyFactory.GetSummaries();
//Assert
Assert.IsNotNull(actual);
Assert.AreEqual(actual.Count(), 0);
}
public void GIVEN_Empty_Reader_WHEN_Retrieving_Workout_IDs_THEN_No_IDS_Retrieved()
{
//Arrange
var emptyFactory = new WorkoutFactory(_emptyXDocReader);
//Act
var ids = emptyFactory.GetIDs();
//Assert
Assert.IsNotNull(ids);
Assert.AreEqual(ids.Count(), 0);
}
public void GIVEN_Valid_Run_XDoc_WHEN_Retrieving_Workouts_Via_Get_THEN_Workout_Returned()
{
var goodFactory = new WorkoutFactory(_validReader);
var actual = goodFactory.GetIDs();
foreach (var workoutID in actual)
{
var workCopy = goodFactory.GetWorkout(workoutID);
//TODO: Validate values in returned entity
Assert.IsNotNull(workCopy, "Invalid Workout Returned");
}
}
public void GIVEN_Valid_Summary_XDoc_WHEN_Retrieving_Workouts_Via_Get_THEN_Workout_Returned()
{
//TODO: Validate values in returned entity
var goodFactory = new WorkoutFactory(_validReader);
IEnumerable<Workout> actual = goodFactory.GetSummaries();
Assert.IsNotNull(actual, "Invalid Workout List Returned");
Assert.AreEqual(actual.Count(), 1, "No Workouts Returned");
}
public void GIVEN_Null_Reader_WHEN_Retrieving_Workouts_Via_Get_THEN_Exception()
{
var nullFactory = new WorkoutFactory(_nullXDocReader);
var workCopy = nullFactory.GetWorkout(1);
}
public void GIVEN_Null_Reader_WHEN_Retrieving_Workout_IDs_THEN_Exception()
{
//Arrange
var nullFactory = new WorkoutFactory(_nullXDocReader);
//Act
var ids = nullFactory.GetIDs();
}
public void GIVEN_Reader_With_Incorrect_Run_WHEN_Retrieving_Workout_By_ID_THEN_Exception()
{
var goodFactory = new WorkoutFactory(_validReader);
var badFactory = new WorkoutFactory(_invalidReader);
foreach (var id in goodFactory.GetIDs())
{
badFactory.GetWorkout(id);
}
}
public void GIVEN_Empty_Reader_WHEN_Retrieving_Workouts_Via_Get_THEN_Exception()
{
//Arrange
var emptyFactory = new WorkoutFactory(_emptyXDocReader);
//Act
var workCopy = emptyFactory.GetWorkout(1);
}
public void GIVEN_Valid_But_Empty_Summaries_WHEN_Retrieving_Workouts_THEN_No_Exception()
{
var badFactory = new WorkoutFactory(_emptyXDocReader);
badFactory.GetSummaries();
}
public void Add(WorkoutModel workout, int userId)
{
WorkoutFactory.CreateWorkoutContainerDAL().Add(workout, userId);
}
public void GIVEN_Valid_But_Incorrect_Summary_XDoc_WHEN_Retrieving_Summaries_THEN_Exception()
{
var badFactory = new WorkoutFactory(_invalidReader);
badFactory.GetSummaries();
}
public List <ExerciseModel> GetExercisesInWorkout(int workoutId)
{
return(WorkoutFactory.CreateWorkoutContainerDAL().GetAllExercises(workoutId));
}
public void UpdateWorkout(int id, string name, string skillevel, int time, string category)
{
WorkoutFactory.CreateWorkoutDAL().UpdateWorkout(id, name, skillevel, time, category);
}
