public async Task <ActionResult <EditGymClassRequest> > editClass(EditGymClassRequest edit)
{
Users user = await userRepository.getUser(edit.EditorUsername);
if (user == null)
{
return(StatusCode(StatusCodes.Status404NotFound, "User making the edit to the class was not found!"));
}
if (user.UserType != UserTypes.Manager && user.UserType != UserTypes.Instructor)
{
return(StatusCode(StatusCodes.Status401Unauthorized, "User making the edit is not a manager or instructor!"));
}
GymClasses target = await classRepository.getClassById(edit.ClassId);
if (target == null)
{
return(StatusCode(StatusCodes.Status404NotFound, "The class you wish to edit does not exist!"));
}
ClassMappers.editRequestToGymClassModel(edit, target);
target = await classRepository.editClass(target);
if (target != null)
{
return(ClassMappers.classToClassRequestModel(target));
}
else
{
return(StatusCode(StatusCodes.Status500InternalServerError, "Something went wrong trying to update the class!"));
}
}
public async Task <ActionResult <ClassRatingResponse> > getClassRating(int classid)
{
GymClasses gymClass = await classRepository.getClassById(classid);
if (gymClass == null)
{
return(StatusCode(StatusCodes.Status404NotFound, "Specified class does not exist!"));
}
ClassRating rating = await classRatingRepository.getRating(classid);
ClassRatingResponse response = new ClassRatingResponse();
if (rating == null)
{
response.classId = classid;
response.ratingCount = 0;
response.ratingSum = 0;
}
else
{
response.classId = rating.ClassIdForeignKey;
response.ratingCount = rating.RatingCount;
response.ratingSum = rating.RatingSum;
}
return(Ok(response));
}
public ActionResult DeleteConfirmed(int id)
{
GymClasses gymClasses = db.GymClasses.Find(id);
db.GymClasses.Remove(gymClasses);
db.SaveChanges();
return(RedirectToAction("Index"));
}
public async Task <ActionResult> cancelClass(CancelClassRequest classRequest)
{
GymClasses classToChange = await classRepository.getClassById(classRequest.classId);
if (classToChange == null)
{
return(NotFound("This class ID does not exist."));
}
if (classToChange.InstructorUsername != classRequest.username)
{
return(Unauthorized("This instructor does not teach this class."));
}
string content = "";
string returnMessage = "";
bool oldWay = classToChange.Cancelled;
if (oldWay)
{
returnMessage = "This class has been resumed.";
}
else
{
content = "We are sad to say, a class you signed up for has been cancelled!\n" +
classToChange.Name + " that was supposed to happen on " + classToChange.Day +
" at " + classToChange.StartTime + ".";
returnMessage = "This class has been cancelled. Remember to resume it when you can.";
}
bool changed = await classRepository.instructorCancelClass(classRequest.classId);
if (changed && (oldWay == false))
{
await mailer.sendEmail("*****@*****.**", "Gym Moves", "Class Cancelled", content, emailReceiver);
//Causes error
/*foreach(ClassRegister user in classToChange.Registers) {
*
* await mailer.sendEmail("*****@*****.**", "Gym Moves", "Class Cancelled", content, user.Student.Email);
* }*/
return(Ok(returnMessage));
}
else if (changed && (oldWay == true))
{
return(Ok(returnMessage));
}
else
{
return(StatusCode(500, "We were unable to change the class on our side. Please try again later."));
}
}
public ActionResult Edit([Bind(Include = "GymClassesID,Title,Introduction,Description,Benefits,GymOverviewID")] GymClasses gymClasses)
{
if (ModelState.IsValid)
{
db.Entry(gymClasses).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(gymClasses));
}
public static GymClasses[] reducedClassToClassModel(GymClassResponse[] sources)
{
GymClasses[] targets = new GymClasses[sources.Length];
for (int i = 0; i < sources.Length; i++)
{
targets[i] = reducedClassToClassModel(sources[i]);
}
return(targets);
}
public async Task <GymClasses> editClass(GymClasses edit)
{
context.Update(edit);
if (await context.SaveChangesAsync() > 0)
{
return(context.Classes.Where(p => p.ClassId == edit.ClassId).FirstOrDefault());
}
else
{
return(null);
}
}
public static void editRequestToGymClassModel(EditGymClassRequest source, GymClasses target)
{
target.ClassId = source.ClassId;
target.InstructorUsername = source.InstructorUsername;
target.Name = source.Name;
target.Description = source.Description;
target.Day = source.Day;
target.StartTime = source.StartTime;
target.EndTime = source.EndTime;
target.MaxCapacity = source.MaxCapacity;
target.Cancelled = source.Cancelled;
}
public async Task <ActionResult <GymClassResponse> > getSpecificClass(int classid)
{
GymClasses targetClass = await classRepository.getClassById(classid);
if (targetClass == null)
{
return(StatusCode(StatusCodes.Status404NotFound, "Specified class was not found!"));
}
GymClassResponse convertedObject = ClassMappers.classModelToReducedModel(targetClass);
return(Ok(convertedObject));
}
public ActionResult Create([Bind(Include = "GymClassesID,Title,Introduction,Description,Benefits,GymOverviewID")] GymClasses gymClasses)
{
var currentGymClass = db.GymOverview.Find(gymClasses.GymOverviewID);
if (ModelState.IsValid)
{
currentGymClass.GymClasses.Add(gymClasses);
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(gymClasses));
}
// GET: GymClasses/Edit/5
public ActionResult Edit(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
GymClasses gymClasses = db.GymClasses.Find(id);
if (gymClasses == null)
{
return(HttpNotFound());
}
return(View(gymClasses));
}
public static EditGymClassRequest classToClassRequestModel(GymClasses source)
{
EditGymClassRequest target = new EditGymClassRequest();
target.ClassId = source.ClassId;
target.InstructorUsername = source.InstructorUsername;
target.Name = source.Name;
target.Description = source.Description;
target.Day = source.Day;
target.StartTime = source.StartTime;
target.EndTime = source.EndTime;
target.MaxCapacity = source.MaxCapacity;
target.Cancelled = source.Cancelled;
return(target);
}
public async Task <bool> removeRegister(ClassRegister register)
{
context.Remove(register);
IQueryable <GymClasses> query = context.Classes;
query = query.Where(p => p.ClassId == register.ClassIdForeignKey);
GymClasses classToUpdate = query.FirstOrDefault();
classToUpdate.CurrentStudents--;
context.Update(classToUpdate);
return((await context.SaveChangesAsync()) > 0);
}
public async Task <ActionResult <bool> > addClass(GymClassRequest newClass)
{
Users personAdding = await userRepository.getUser(newClass.Username);
if (personAdding == null)
{
return(StatusCode(StatusCodes.Status404NotFound, "The user requesting for " +
"the class to be added could not be found!"));
}
if (personAdding.UserType == UserTypes.Manager)
{
if (personAdding.GymIdForeignKey == newClass.NewClass.GymId)
{
GymClasses newClassModel = ClassMappers.reducedClassToClassModel(newClass.NewClass);
if (await classRepository.getInstructorClassAtSpecificDateTime(newClassModel.InstructorUsername,
newClassModel.Day, newClassModel.StartTime) == null)
{
if (await classRepository.addClass(newClassModel))
{
return(Ok(true));
}
else
{
return(StatusCode(StatusCodes.Status500InternalServerError, "An error occurred attempting " +
"to add the new class to the database!"));
}
}
else
{
return(StatusCode(StatusCodes.Status403Forbidden, "Designated instructor already has a class " +
"starting at the given start time!"));
}
}
else
{
return(StatusCode(StatusCodes.Status403Forbidden, "Managers can only add new classes for the gym " +
"they're assigned to!"));
}
}
else
{
return(StatusCode(StatusCodes.Status401Unauthorized, "Only managers can add new classes!"));
}
}
public async Task <GymClasses[]> getUserClasses(string username)
{
ClassRegister[] registerList = await registerRepository.getUserRegisters(username);
if (registerList.Length == 0)
{
return(new GymClasses[0]);
}
GymClasses[] classList = new GymClasses[registerList.Length];
for (int i = 0; i < registerList.Length; i++)
{
classList[i] = await getClassById(registerList[i].ClassIdForeignKey);
}
return(classList);
}
public static GymClasses reducedClassToClassModel(GymClassResponse source)
{
GymClasses target = new GymClasses();
target.ClassId = source.ClassId;
target.GymIdForeignKey = source.GymId;
target.InstructorUsername = source.Instructor;
target.Name = source.Name;
target.Description = source.Description;
target.Day = source.Day;
target.StartTime = source.StartTime;
target.EndTime = source.EndTime;
target.MaxCapacity = source.MaxCapacity;
target.CurrentStudents = source.CurrentStudents;
target.Cancelled = source.Cancelled;
return(target);
}
public async Task <ActionResult <bool> > removeClass(GymClassRemoveRequest removeClass)
{
Users user = await userRepository.getUser(removeClass.Username);
if (user == null)
{
return(StatusCode(StatusCodes.Status404NotFound, "The user requesting for the class to be removed could not be found!"));
}
if (user.UserType == UserTypes.Manager)
{
GymClasses targetClass = await classRepository.getClassById(removeClass.ClassId);
if (targetClass == null)
{
return(StatusCode(StatusCodes.Status404NotFound, "The class being removed was not found!"));
}
if (targetClass.GymIdForeignKey != user.GymIdForeignKey)
{
return(StatusCode(StatusCodes.Status401Unauthorized, "Managers can only remove class for their own gym!"));
}
/* Multithread remove and notifying users */
await classAttendanceRepository.removeClass(targetClass.ClassId);
if (await classRepository.removeClass(targetClass) == true)
{
return(Ok(true));
}
else
{
return(StatusCode(StatusCodes.Status500InternalServerError, "Something went wrong removing the class from the database!"));
}
}
return(StatusCode(StatusCodes.Status401Unauthorized, "Only managers can remove classes!"));
}
public async Task <ActionResult <bool> > signUpUserToClass(RegisterUserForClassRequest register)
{
if (await classRepository.getClassById(register.ClassId) == null)
{
return(StatusCode(StatusCodes.Status404NotFound, "The class the user wants to signup for does not exist!"));
}
if (await userRepository.getUser(register.Username) == null)
{
return(StatusCode(StatusCodes.Status404NotFound, "The user does not exist!"));
}
ClassRegister existingRegister = await registerRepository.getSpecificUserAndClass(register.Username, register.ClassId);
if (existingRegister == null)
{
GymClasses targetClass = await classRepository.getClassById(register.ClassId);
if (targetClass.CurrentStudents < targetClass.MaxCapacity)
{
if (await registerRepository.addRegister(RegisterMapper.registerUserForClassToClassRegister(register)))
{
return(Ok(true));
}
else
{
return(StatusCode(StatusCodes.Status500InternalServerError, "An error occurred while trying to register the user for the class!"));
}
}
else
{
return(StatusCode(StatusCodes.Status400BadRequest, "Class max capacity reached!"));
}
}
else
{
return(StatusCode(StatusCodes.Status400BadRequest, "User is already signed up for the specified class"));
}
}
public async Task <bool> managerDeleteClass(GymClasses classToDelete)
{
context.Remove(classToDelete);
return((await context.SaveChangesAsync()) > 0);
}
public async Task <ActionResult <bool> > deregisterUserFromClass(RegisterUserForClassRequest register)
{
if (await classRepository.getClassById(register.ClassId) == null)
{
return(StatusCode(StatusCodes.Status404NotFound, "The class the user wants to signup for does not exist!"));
}
if (await userRepository.getUser(register.Username) == null)
{
return(StatusCode(StatusCodes.Status404NotFound, "The user does not exist!"));
}
ClassRegister existingRegister = await registerRepository.getSpecificUserAndClass(register.Username, register.ClassId);
if (existingRegister == null)
{
return(StatusCode(StatusCodes.Status404NotFound, "User is not signed up for the class!"));
}
if (await registerRepository.removeRegister(existingRegister))
{
DayOfWeek today = DateTime.Today.DayOfWeek;
DateTime date;
GymClasses targetClass = await classRepository.getClassById(register.ClassId);
if (today.ToString().ToLower() == targetClass.Day.ToLower())
{
date = DateTime.Today.Date;
}
else
{
DayOfWeek dayOfClass;
switch (targetClass.Day.ToLower())
{
case "monday":
dayOfClass = DayOfWeek.Monday;
break;
case "tuesday":
dayOfClass = DayOfWeek.Tuesday;
break;
case "wednesday":
dayOfClass = DayOfWeek.Wednesday;
break;
case "thursday":
dayOfClass = DayOfWeek.Thursday;
break;
case "friday":
dayOfClass = DayOfWeek.Friday;
break;
case "saturday":
dayOfClass = DayOfWeek.Saturday;
break;
default:
dayOfClass = DayOfWeek.Sunday;
break;
}
int difference = days[(int)today, (int)dayOfClass];
date = DateTime.Today.AddDays(difference).Date;
}
ClassAttendance classToChange = await classAttendanceRepository.getClassInstance(register.ClassId, date);
if (classToChange == null)
{
ClassAttendance newClass = new ClassAttendance();
newClass.Date = date;
newClass.ClassId = targetClass.ClassId;
newClass.Capacity = targetClass.MaxCapacity;
newClass.Class = targetClass;
newClass.NumberOfStudents = targetClass.CurrentStudents;
await classAttendanceRepository.addNewClassInstance(newClass);
}
else
{
await classAttendanceRepository.editClassAttendance(classToChange.ClassId, classToChange.Date, -1);
}
return(Ok(true));
}
else
{
return(StatusCode(StatusCodes.Status500InternalServerError, "An error occurred while attempting to remove the register from the database!"));
}
}
public async Task <bool> addClass(GymClasses gymClass)
{
context.Add(gymClass);
return((await context.SaveChangesAsync()) > 0);
}
public async Task <ActionResult <ClassRatingResponse> > rateClass(ClassRatingRequest request)
{
/* Validate User Exists */
Users user = await userRepository.getUser(request.username);
if (user == null)
{
return(StatusCode(StatusCodes.Status401Unauthorized, "User specified is not a valid user!"));
}
/* Validate Class Exists */
GymClasses gymClass = await classRepository.getClassById(request.classId);
if (gymClass == null)
{
return(StatusCode(StatusCodes.Status404NotFound, "Specified class does not exist!"));
}
/* Validate From Same Gym */
if (gymClass.GymIdForeignKey != user.GymIdForeignKey)
{
return(StatusCode(StatusCodes.Status401Unauthorized, "User rating the class is not from the same gym as the class!"));
}
/* Validate Not Instructor Of Class */
if (gymClass.InstructorUsername == user.Username)
{
return(StatusCode(StatusCodes.Status401Unauthorized, "Instructors cannot rate their own classes!"));
}
/* Validate Rating Out Of 5 */
if (request.rating > 5 || request.rating < 0)
{
return(StatusCode(StatusCodes.Status400BadRequest, "Rating provided is out of allowed range!"));
}
/* Check if existing rating record exists */
ClassRating rating = await classRatingRepository.getRating(request.classId);
if (rating == null)
{
rating = new ClassRating();
rating.ClassIdForeignKey = request.classId;
rating.RatingCount = 0;
rating.RatingCount = 0;
if (!(await classRatingRepository.addRating(rating)))
{
return(StatusCode(StatusCodes.Status500InternalServerError, "Something went wrong creating the rating record for the class!"));
}
}
rating.RatingCount++;
rating.RatingSum += request.rating;
if (!(await classRatingRepository.rateClass(rating)))
{
return(StatusCode(StatusCodes.Status500InternalServerError, "Something went wrong adding your rating to the database!"));
}
ClassRatingResponse response = new ClassRatingResponse();
response.classId = rating.ClassIdForeignKey;
response.ratingCount = rating.RatingCount;
response.ratingSum = rating.RatingSum;
return(Ok(response));
}
public async Task <bool> removeClass(GymClasses gymClass)
{
context.Remove(gymClass);
return((await context.SaveChangesAsync()) > 0);
}
