public void TestMyWorkoutsDeleteCompletedMyWorkout()
{
user_workout u_workout = new user_workout();
u_workout.id = 2;
u_workout.workout = new workout()
{
id = 2
};
u_workout.date_finished = Convert.ToDateTime("2015-06-30");
byte[] timestamp = new byte[8];
for (var i = 0; i < timestamp.Length; i++)
{
timestamp[i] = 0;
}
u_workout.timestamp = timestamp;
db.Setup(c => c.user_workout.Find(u_workout.id)).Returns(u_workout);
db.Setup(c => c.user_workout.Remove(u_workout)).Returns(u_workout);
ViewResult result = myWorkoutsCon.DeleteFromMyWorkouts(u_workout) as ViewResult;
Assert.IsNotNull(result);
Assert.AreEqual("DetailedError", result.ViewName);
Assert.IsInstanceOfType(result.Model, typeof(HttpStatusCodeResult));
var model = result.Model as HttpStatusCodeResult;
Assert.AreEqual(500, model.StatusCode);
Assert.AreEqual("The workout has been completed and can't be removed", model.StatusDescription);
}
public ActionResult AddToMyWorkouts(user_workout userWorkout)
{
int userID = userAccess.getUserId(User.Identity.Name);
if (userID == -1)
{
return(View());
}
userWorkout.user_id = userID;
userWorkout.number_of_ex_completed = 0;
if (ModelState.IsValid)
{
try
{
db.user_workout.Add(userWorkout);
db.SaveChanges();
return(RedirectToAction("Details", "MyWorkouts", new { user_workout_id = userWorkout.id }));
}
catch (Exception ex)
{
return(View("DetailedError", new HttpStatusCodeResult(HttpStatusCode.InternalServerError, "Failed to add the requested workout to user workouts.")));
}
}
else
{
return(View("DetailedError", new HttpStatusCodeResult(HttpStatusCode.BadRequest, "Failed to add the requested workout to user workouts due to an invalid entry.")));
}
}
public void TestMyWorkoutsDeleteMyWorkout()
{
user_workout u_workout = new user_workout();
u_workout.id = 2;
u_workout.workout = new workout()
{
id = 2
};
byte[] timestamp = new byte[8];
for (var i = 0; i < timestamp.Length; i++)
{
timestamp[i] = 0;
}
u_workout.timestamp = timestamp;
db.Setup(c => c.user_workout.Find(u_workout.id)).Returns(u_workout);
db.Setup(c => c.user_workout.Remove(u_workout)).Returns(u_workout);
RedirectToRouteResult result = myWorkoutsCon.DeleteFromMyWorkouts(u_workout) as RedirectToRouteResult;
RedirectToRouteResult v_result = myWorkoutsCon.Details(2) as RedirectToRouteResult;
Assert.IsNull(v_result);
Assert.IsNotNull(result);
Assert.AreEqual("Index", result.RouteValues["action"], "action was not Index");
Assert.AreEqual("MyWorkouts", result.RouteValues["controller"], "controller was not MyWorkouts");
}
public void Initialize()
{
DbContextHelpers contextHelpers = new DbContextHelpers();
db = contextHelpers.getDbContext();
search = new WorkoutSearch();
myWorkoutsCon = new MyWorkoutsController(db.Object)
{
ControllerContext = MockContext.AuthenticationContext("jjones")
};
myWorkoutsCon.pageSize = 10;
ts = new byte[] { 0, 0, 0, 0, 0, 0, 0, 0 };
uWorkout = new user_workout()
{
id = 1,
number_of_ex_completed = 0,
workout_id = 1,
user_id = 2,
timestamp = ts,
workout = new workout()
{
workout_exercise = new List <workout_exercise>
{
{ new workout_exercise() },
{ new workout_exercise() },
{ new workout_exercise() },
{ new workout_exercise() },
}
}
};
}
public ActionResult Details(int?user_workout_id)
{
workout workout;
if (user_workout_id == null)
{
return(View("DetailedError", new HttpStatusCodeResult(HttpStatusCode.BadRequest, "Workout could not be retrieved with given parameters.")));
}
int userId = userAccess.getUserId(User.Identity.Name);
user_workout myworkout = db.user_workout.Find(user_workout_id);
if (myworkout == null)
{
return(View("DetailedError", new HttpStatusCodeResult(HttpStatusCode.NotFound, "Your workout could not be found.")));
}
else
{
workout = myworkout.workout;
ViewBag.myWorkoutId = myworkout.id;
ViewBag.numExercisesCompleted = myworkout.number_of_ex_completed;
ViewBag.isMyWorkout = true;
ViewBag.timestampString = timestampByteArrToString(myworkout.timestamp);
// Workout id is stored in session to be accessed from AddComment post method
if (workout != null)
{
Session["workout_id"] = workout.id;
}
// Checks if workout is in Favorite list
int userID = userAccess.getUserId(User.Identity.Name);
user_favorite_workout fav_workout = db.user_favorite_workout
.Where(m => m.workout_id == (int)workout.id &&
m.user_id == userID).FirstOrDefault();
ViewBag.IsFavorite = (fav_workout == null) ? false : true;
//counts how many users marked workout as Favorite
ViewBag.FavoritesCount = db.user_favorite_workout.Where(m => m.workout_id.Equals((int)workout.id)).Count();
var workout_rating = db.workout_rating.Where(m => m.workout_id == workout.id).FirstOrDefault();
if (workout_rating != null)
{
ViewBag.average_rating = workout_rating.average_rating;
}
else
{
ViewBag.average_rating = null;
}
return(View(workout));
}
}
public void TestMyWorkoutsAddWorkoutWithBadWorkout()
{
user_workout u_workout = new user_workout();
ViewResult result = myWorkoutsCon.AddToMyWorkouts(u_workout) as ViewResult;
Assert.IsNotNull(result);
Assert.AreEqual("DetailedError", result.ViewName);
Assert.IsInstanceOfType(result.Model, typeof(HttpStatusCodeResult));
var model = result.Model as HttpStatusCodeResult;
Assert.AreEqual(500, model.StatusCode);
Assert.AreEqual("Failed to add the requested workout to user workouts.", model.StatusDescription);
}
public void TestAddWorkoutToMyWorkouts()
{
user_workout userWorkout = new user_workout();
userWorkout.workout_id = 1;
db.Setup(c => c.user_workout.Add(userWorkout)).Returns(userWorkout);
RedirectToRouteResult result = myWorkoutsCon.AddToMyWorkouts(userWorkout) as RedirectToRouteResult;
Assert.IsNotNull(result);
Assert.AreEqual(0, result.RouteValues["user_workout_id"], "workoutId was not 1");
Assert.AreEqual("Details", result.RouteValues["action"], "action was not Controller");
Assert.AreEqual("MyWorkouts", result.RouteValues["controller"], "controller was not Home");
}
public void TestMyWorkoutsDeleteWorkoutNotFound()
{
user_workout u_workout = new user_workout();
u_workout.id = 50406;
ViewResult result = myWorkoutsCon.DeleteFromMyWorkouts(u_workout) as ViewResult;
Assert.IsNotNull(result);
Assert.AreEqual("DetailedError", result.ViewName);
Assert.IsInstanceOfType(result.Model, typeof(HttpStatusCodeResult));
var model = result.Model as HttpStatusCodeResult;
Assert.AreEqual(500, model.StatusCode);
Assert.AreEqual("The workout does not exist or has already been deleted", model.StatusDescription);
}
/* Private Test Helpers */
/// <summary>
/// Helper method to determin if my workouts list is sorted in a certain order on a certain property
/// </summary>
/// <param name="workouts">The workout list to check</param>
/// <param name="propName">The workout property that the list should be sorted by</param>
/// <param name="order">One of "asc" or "desc". Tells the method to check if the list is in ascending or descending order</param>
/// <returns>True if the list is sorted on the given property in the given order, false otherwise</returns>
private bool isSorted(PagedList <user_workout> workouts, string propName, string order)
{
int limit = (workouts.Count > 10) ? 11 : workouts.Count;
for (int i = 1; i < limit; i++)
{
user_workout currentWorkout = workouts[i];
user_workout prevWorkout = workouts[i - 1];
int? res = null;
if (propName == "name")
{
res = String.Compare(prevWorkout.workout.name, currentWorkout.workout.name);
}
else if (propName == "category")
{
res = String.Compare(prevWorkout.workout.category.name, currentWorkout.workout.category.name);
}
else if (propName == "dateCreated")
{
res = DateTime.Compare(prevWorkout.workout.created_at, currentWorkout.workout.created_at);
}
else if (propName == "username")
{
res = String.Compare(prevWorkout.workout.user.username, currentWorkout.workout.user.username);
}
else
{
return(false);
}
if (order == "asc")
{
if (res > 0)
{
return(false);
}
}
else if (order == "desc")
{
if (res < 0)
{
return(false);
}
}
}
return(true);
}
public ActionResult DeleteFromMyWorkouts([Bind(Include = "id,timestamp")] user_workout userWorkout)
{
int userID = userAccess.getUserId(User.Identity.Name);
if (userID == -1)
{
return(View());
}
try
{
user_workout oldUserWorkout = db.user_workout.Find(userWorkout.id);
if (oldUserWorkout == null)
{
return(View("DetailedError", new HttpStatusCodeResult(HttpStatusCode.InternalServerError, "The workout does not exist or has already been deleted")));
}
if (oldUserWorkout.date_finished != null)
{
return(View("DetailedError", new HttpStatusCodeResult(HttpStatusCode.InternalServerError, "The workout has been completed and can't be removed")));
}
var entry = db.Entry(oldUserWorkout);
var state = entry.State;
if (state == EntityState.Detached)
{
db.user_workout.Remove(userWorkout);
}
else
{
entry.OriginalValues["timestamp"] = userWorkout.timestamp;
db.user_workout.Remove(oldUserWorkout);
}
db.SaveChanges();
return(RedirectToAction("Index", "MyWorkouts"));
}
catch (DbUpdateConcurrencyException ex)
{
return(View("DetailedError", new HttpStatusCodeResult(HttpStatusCode.InternalServerError, "Failed to remove workout as another user may have updated this workout")));
}
catch (DbUpdateException ex)
{
return(View("DetailedError", new HttpStatusCodeResult(HttpStatusCode.InternalServerError, "Failed to remove the workout.")));
}
catch (Exception ex)
{
return(View("DetailedError", new HttpStatusCodeResult(HttpStatusCode.InternalServerError, "Failed to delete the requested workout from MyWorkouts.")));
}
}
public void TestMyWorkoutsDetailsForWorkout24()
{
user_workout u_workout = new user_workout();
u_workout.id = 10;
byte[] timestamp = new byte[8];
for (var i = 0; i < timestamp.Length; i++)
{
timestamp[i] = 0;
}
u_workout.timestamp = timestamp;
u_workout.workout = new workout
{
description = "desc2"
};
db.Setup(c => c.user_workout.Find(u_workout.id)).Returns(u_workout);
ViewResult result = myWorkoutsCon.Details(10) as ViewResult;
Assert.IsNotNull(result);
workout workout10 = (workout)result.ViewData.Model;
Assert.AreEqual("desc2", workout10.description, "description was not 'desc24'");
}
public void TestMyWorkoutsDetailsForWorkout1()
{
user_workout u_workout = new user_workout();
u_workout.id = 1;
byte[] timestamp = new byte[8];
for (var i = 0; i < timestamp.Length; i++)
{
timestamp[i] = 0;
}
u_workout.timestamp = timestamp;
u_workout.workout = new workout
{
name = "workout1"
};
db.Setup(c => c.user_workout.Find(u_workout.id)).Returns(u_workout);
ViewResult result = myWorkoutsCon.Details(1) as ViewResult;
Assert.IsNotNull(result);
workout workout1 = (workout)result.ViewData.Model;
Assert.AreEqual("workout1", workout1.name, "Name was not 'workout1'");
}
public ActionResult MarkExercise(int my_workout_id, int position, string timestampString)
{
byte[] timestamp = timestampStringToByteArr(timestampString);
user_workout userWorkout = new user_workout();
userWorkout.id = my_workout_id;
userWorkout.timestamp = timestamp;
user_workout oldMyWorkout = db.user_workout.Find(my_workout_id);
if (oldMyWorkout == null)
{
var result = new Dictionary <string, string>();
result.Add("error", "true");
result.Add("position", Convert.ToString(position));
result.Add("message", "Failed to mark progress as the workout does not exist or may have been deleted");
result.Add("code", "500");
return(Json(result));
}
try
{
var entry = db.Entry(oldMyWorkout);
var state = entry.State;
int totalNumExercises = oldMyWorkout.workout.workout_exercise.Count;
if (position == 1 || oldMyWorkout.date_started == null)
{
userWorkout.date_started = DateTime.Now;
if (position == totalNumExercises)
{
userWorkout.date_finished = DateTime.Now;
}
}
else if (position == totalNumExercises)
{
userWorkout.date_finished = DateTime.Now;
}
userWorkout.number_of_ex_completed = position;
if (state == EntityState.Detached)
{
db.Entry(userWorkout).State = EntityState.Modified;
}
else
{
entry.OriginalValues["timestamp"] = userWorkout.timestamp;
if (userWorkout.date_started != null)
{
entry.CurrentValues["date_started"] = userWorkout.date_started;
}
if (userWorkout.date_finished != null)
{
entry.CurrentValues["date_finished"] = userWorkout.date_finished;
}
entry.CurrentValues["number_of_ex_completed"] = userWorkout.number_of_ex_completed;
}
db.SaveChanges();
user_workout updatedMyWorkout = db.user_workout.Find(my_workout_id);
string newTimestamp = timestampByteArrToString(updatedMyWorkout.timestamp);
var result = new Dictionary <string, string>();
result.Add("success", "true");
result.Add("timestampString", newTimestamp);
result.Add("error", "false");
var isCompleted = (userWorkout.date_finished != null) ? "true" : "false";
result.Add("isCompleted", isCompleted);
return(Json(result));
}
catch (DbUpdateConcurrencyException ex)
{
var result = new Dictionary <string, string>();
result.Add("error", "true");
result.Add("position", Convert.ToString(position));
result.Add("message", "Failed to mark progress as the workout may have already been updated");
result.Add("code", "500");
return(Json(result));
}
catch (DbUpdateException ex)
{
var result = new Dictionary <string, string>();
result.Add("error", "true");
result.Add("position", Convert.ToString(position));
result.Add("message", "Failed to mark progress as the workout may have already been updated");
result.Add("code", "500");
return(Json(result));
}
catch (Exception ex)
{
var result = new Dictionary <string, string>();
result.Add("error", "true");
result.Add("position", Convert.ToString(position));
result.Add("message", "Failed to mark workout progress");
result.Add("code", "500");
return(Json(result));
}
}
