//
// GET: /Courses/Details/5
public ActionResult Details(int id = 0)
{
Course course = _courseProducer.Get(new Course()
{
ID = id
});
if (course == null)
{
return(HttpNotFound());
}
return(View(course));
}
public ActionResult Details(int id = 0)
{
//Plan plan = plans.Find(id);
Plan plan = _planProducer.Get(new Plan()
{
ID = id
});
if (plan == null)
{
return(HttpNotFound());
}
if (webSecurity.CurrentUser.IsInRole("Advisor") || plan.userID == webSecurity.CurrentUserId)
{
//var semesterList = semesters.Where(s => s.ID > plan.semesterID);
var semesterList = _semesterProducer.GetAll().Where(s => s.ID > plan.semesterID);
ViewBag.semesterID = new SelectList(semesterList.AsEnumerable(), "ID", "semesterName");
return(View(plan));
}
else
{
return(HttpNotFound());
}
}
public ActionResult UpdateCourseInfo(int id = 0)
{
if (id > 0)
{
//PlanCourse pcourse = planCourses.Find(id);
PlanCourse pcourse = _planCourseProducer.Get(new PlanCourse()
{
ID = id
});
if (pcourse != null)
{
//Plan planAttached = plans.Find(pcourse.planID);
Plan planAttached = pcourse.plan;
if (webSecurity.CurrentUser.IsInRole("Advisor") || planAttached.userID == webSecurity.CurrentUserId)
{
if (pcourse.electiveListID != null)
{
List <DropdownCourse> courses = new List <DropdownCourse>();
List <ElectiveListCourse> elistCourses = pcourse.electiveList.courses.ToList();
foreach (ElectiveListCourse elistc in elistCourses)
{
DropdownCourse now = new DropdownCourse();
now.ID = elistc.courseID;
now.courseHeader = elistc.course.courseHeader;
courses.Add(now);
}
if (pcourse.courseID != null)
{
ViewBag.courseID = new SelectList(courses.AsEnumerable(), "ID", "courseHeader", pcourse.courseID);
}
else
{
ViewBag.courseID = new SelectList(courses.AsEnumerable(), "ID", "courseHeader");
}
}
return(PartialView("PlanCourseFormPartial", new PlanCourseEdit(pcourse)));
}
}
}
return(HttpNotFound());
}
//
// GET: /DegreePrograms/Details/5
public ActionResult Details(int id = 0)
{
//DegreeProgram degreeprogram = degreePrograms.Find(id);
DegreeProgram degreeprogram = _degreeProgramProducer.Get(new DegreeProgram()
{
ID = id
});
if (degreeprogram == null)
{
return(HttpNotFound());
}
degreeprogram.requiredCourses = degreeprogram.requiredCourses.OrderBy(reqcourse => reqcourse.semester).ThenBy(reqcourse => reqcourse.course.coursePrefix).ThenBy(reqcourse => reqcourse.course.courseNumber).ToList();
degreeprogram.electiveCourses = degreeprogram.electiveCourses.OrderBy(eleccourse => eleccourse.semester).ThenBy(eleccourse => eleccourse.electiveList.electiveListName).ToList();
return(View(degreeprogram));
}
//
// GET: /ElectiveLists/Details/5
public ActionResult Details(int id = 0)
{
//ElectiveList electivelist = electiveLists.Find(id);
ElectiveList electivelist = _electiveListProducer.Get(new ElectiveList()
{
ID = id
});
if (electivelist == null)
{
return(HttpNotFound());
}
electivelist.courses = electivelist.courses.OrderBy(course => course.course.coursePrefix).ThenBy(course => course.course.courseNumber).ToList();
return(View(electivelist));
}
public ActionResult Edit(ElectiveList electivelist, IEnumerable <ElectiveListCourse> ElectiveListCourses)
{
if (ModelState.IsValid)
{
//ElectiveList elistAttached = electiveLists.Where(elist => elist.ID == electivelist.ID).First();
ElectiveList elistAttached = _electiveListProducer.Get(new ElectiveList()
{
ID = electivelist.ID
});
electivelist.courses = elistAttached.courses;
if (ElectiveListCourses == null)
{
ElectiveListCourses = new List <ElectiveListCourse>();
}
//figure out the courses that were removed from the list
LinkedList <ElectiveListCourse> toRemove = new LinkedList <ElectiveListCourse>();
foreach (ElectiveListCourse course in elistAttached.courses)
{
if (course.ID > 0)
{
if (!ElectiveListCourses.Contains(course))
{
//ElectiveListCourse elcourseAttached = electiveListCourses.Where(reqc => reqc.ID == course.ID).First();
ElectiveListCourse elcourseAttached = _electiveListCourseProducer.Get(new ElectiveListCourse()
{
ID = course.ID
});
toRemove.AddFirst(elcourseAttached);
}
}
}
//remove those courses from the database
while (toRemove.Count > 0)
{
ElectiveListCourse removeme = toRemove.First();
toRemove.RemoveFirst();
//electiveListCourses.Remove(removeme);
_electiveListCourseProducer.Remove(removeme);
}
//clear the list
electivelist.courses.Clear();
//add the existing courses to the database
foreach (ElectiveListCourse elcourse in ElectiveListCourses)
{
ElectiveListCourse elcourseAttached = null;;
if (elcourse.ID > 0)
{
//elcourseAttached = electiveListCourses.Where(reqc => reqc.ID == elcourse.ID).First();
elcourseAttached = _electiveListCourseProducer.Get(new ElectiveListCourse()
{
ID = elcourse.ID
});
//electiveListCourses.UpdateValues(elcourseAttached, elcourse);
_electiveListCourseProducer.Update(elcourse);
}
else
{
//if (courses.Find(elcourse.courseID) != null)
if (_courseProducer.Get(new Course()
{
ID = elcourse.courseID
}) != null)
{
//electiveListCourses.Add(elcourse);
//electiveListCourses.SaveChanges();
_electiveListCourseProducer.Create(elcourse);
//elcourseAttached = electiveListCourses.Where(reqc => reqc.ID == elcourse.ID).First();
elcourseAttached = _electiveListCourseProducer.Get(new ElectiveListCourse()
{
ID = elcourse.ID
});
}
}
if (elcourseAttached != null)
{
electivelist.courses.Add(elcourseAttached);
}
}
//electiveLists.UpdateValues(elistAttached, electivelist);
//electiveLists.SaveChanges();
_electiveListProducer.Update(electivelist);
return(RedirectToAction("Index"));
}
if (ElectiveListCourses != null)
{
foreach (ElectiveListCourse course in ElectiveListCourses)
{
if (course.courseID > 0)
{
//course.course = courses.Find(course.courseID);
course.course = _courseProducer.Get(new Course()
{
ID = course.courseID
});
}
}
}
electivelist.courses = ElectiveListCourses.ToList();
return(View(electivelist));
}
public ActionResult Edit(Course course, IEnumerable <PrerequisiteCourse> PrerequisiteCourses)
{
var courseList = _courseProducer.GetAll();
if (ModelState.IsValid)
{
Course cAttached = courseList.AsQueryable().Where(c => c.ID == course.ID).First();
course.prerequisites = cAttached.prerequisites;
if (PrerequisiteCourses == null)
{
PrerequisiteCourses = new List <PrerequisiteCourse>();
}
if (course.prerequisites == null)
{
course.prerequisites = new List <PrerequisiteCourse>();
}
//figure out the courses that were removed from the list
LinkedList <PrerequisiteCourse> toRemove = new LinkedList <PrerequisiteCourse>();
foreach (PrerequisiteCourse pcourse in course.prerequisites)
{
if (course.ID > 0)
{
if (!PrerequisiteCourses.Contains(pcourse))
{
//PrerequisiteCourse elcourseAttached = prerequisiteCourses.Where(reqc => reqc.ID == pcourse.ID).First();
PrerequisiteCourse elcourseAttached = _prerequisiteCourseProducer.Get(new PrerequisiteCourse()
{
ID = pcourse.ID
});
toRemove.AddFirst(elcourseAttached);
}
}
}
//remove those courses from the database
while (toRemove.Count > 0)
{
PrerequisiteCourse removeme = toRemove.First();
toRemove.RemoveFirst();
//prerequisiteCourses.Remove(removeme);
_prerequisiteCourseProducer.Remove(removeme);
}
//clear the list
course.prerequisites.Clear();
//add the existing courses to the database
foreach (PrerequisiteCourse pcourse in PrerequisiteCourses)
{
PrerequisiteCourse pcourseAttached = null;;
if (pcourse.ID > 0)
{
//pcourseAttached = prerequisiteCourses.Where(reqc => reqc.ID == pcourse.ID).First();
pcourseAttached = _prerequisiteCourseProducer.Get(new PrerequisiteCourse()
{
ID = pcourse.ID
});
//prerequisiteCourses.UpdateValues(pcourseAttached, pcourse);
_prerequisiteCourseProducer.Update(pcourse); //TODO: check if works correctly or need to switch w/ pcourseAttached
}
else
{
if (courseList.FirstOrDefault(x => x.ID == pcourse.prerequisiteCourseID) != null)
{
//prerequisiteCourses.Add(pcourse);
//prerequisiteCourses.SaveChanges();
_prerequisiteCourseProducer.Create(pcourse);
//pcourseAttached = prerequisiteCourses.Where(reqc => reqc.ID == pcourse.ID).First();
pcourseAttached = _prerequisiteCourseProducer.Get(new PrerequisiteCourse()
{
ID = pcourse.ID
});
}
}
if (pcourseAttached != null)
{
course.prerequisites.Add(pcourseAttached);
}
}
//courses.UpdateValues(cAttached, course);
//courses.SaveChanges();
return(RedirectToAction("Index"));
}
if (PrerequisiteCourses != null)
{
foreach (PrerequisiteCourse pcourse in PrerequisiteCourses)
{
if (pcourse.prerequisiteCourseID > 0)
{
//pcourse.prerequisiteCourse = courses.Find(pcourse.prerequisiteCourseID);
pcourse.prerequisiteCourse = courseList.FirstOrDefault(x => x.ID == pcourse.prerequisiteCourseID);
}
}
}
course.prerequisites = PrerequisiteCourses.ToList();
return(View(course));
}
public T Find(T data)
{
return(_producer.Get(data));
}
public ActionResult Edit(DegreeProgram degreeprogram, IEnumerable <RequiredCourse> RequiredCourses, IEnumerable <ElectiveCourse> ElectiveCourses)
{
if (ModelState.IsValid)
{
//DegreeProgram degreeAttached = degreePrograms.Where(degree => degree.ID == degreeprogram.ID).First();
DegreeProgram degreeAttached = _degreeProgramProducer.Get(new DegreeProgram()
{
ID = degreeprogram.ID
});
degreeprogram.requiredCourses = degreeAttached.requiredCourses;
degreeprogram.electiveCourses = degreeAttached.electiveCourses;
if (RequiredCourses == null)
{
RequiredCourses = new List <RequiredCourse>();
}
if (ElectiveCourses == null)
{
ElectiveCourses = new List <ElectiveCourse>();
}
//figures out which courses were deleted from the form
LinkedList <RequiredCourse> toRemove = new LinkedList <RequiredCourse>();
foreach (RequiredCourse course in degreeAttached.requiredCourses)
{
if (course.ID > 0)
{
if (!RequiredCourses.Contains(course))
{
//RequiredCourse reqcourseAttached = requiredCourses.Where(reqc => reqc.ID == course.ID).First();
RequiredCourse reqcourseAttached = _requiredCourseProducer.Get(new RequiredCourse()
{
ID = course.ID
});
toRemove.AddFirst(reqcourseAttached);
}
}
}
//deletes those courses from the list
while (toRemove.Count > 0)
{
RequiredCourse removeme = toRemove.First();
toRemove.RemoveFirst();
//requiredCourses.Remove(removeme);
_requiredCourseProducer.Remove(removeme);
}
//clears the list
degreeprogram.requiredCourses.Clear();
//adds the courses that exist to the list
foreach (RequiredCourse reqcourse in RequiredCourses)
{
RequiredCourse reqcourseAttached = null;;
if (reqcourse.ID > 0)
{
//reqcourseAttached = requiredCourses.Where(reqc => reqc.ID == reqcourse.ID).First();
reqcourseAttached = _requiredCourseProducer.Get(new RequiredCourse()
{
ID = reqcourse.ID
});
//requiredCourses.UpdateValues(reqcourseAttached, reqcourse);
_requiredCourseProducer.Update(reqcourse);
}
else
{
//if (courses.Find(reqcourse.courseID) != null)
if (_courseProducer.Get(new Course()
{
ID = reqcourse.courseID
}) != null)
{
//requiredCourses.Add(reqcourse);
//requiredCourses.SaveChanges();
_requiredCourseProducer.Create(reqcourse);
//reqcourseAttached = requiredCourses.Where(reqc => reqc.ID == reqcourse.ID).First();
reqcourseAttached = _requiredCourseProducer.Get(new RequiredCourse()
{
ID = reqcourse.ID
});
}
}
if (reqcourseAttached != null)
{
degreeprogram.requiredCourses.Add(reqcourseAttached);
}
}
//figures out which elective lists were deleted from the list
LinkedList <ElectiveCourse> toRemoveMe = new LinkedList <ElectiveCourse>();
foreach (ElectiveCourse course in degreeAttached.electiveCourses)
{
if (!ElectiveCourses.Contains(course))
{
//ElectiveCourse elcourseAttached = electiveCourses.Where(elc => elc.ID == course.ID).First();
ElectiveCourse elcourseAttached = _electiveCourseProducer.Get(new ElectiveCourse()
{
ID = course.ID
});
toRemoveMe.AddFirst(elcourseAttached);
}
}
//remove those elective lists from the list
while (toRemoveMe.Count > 0)
{
ElectiveCourse removeme = toRemoveMe.First();
toRemoveMe.RemoveFirst();
//electiveCourses.Remove(removeme);
_electiveCourseProducer.Remove(removeme);
}
//clear the list
degreeprogram.electiveCourses.Clear();
//add the existing elective lists to the list
foreach (ElectiveCourse elcourse in ElectiveCourses)
{
ElectiveCourse elcourseAttached = null;;
if (elcourse.ID > 0)
{
//elcourseAttached = electiveCourses.Where(elc => elc.ID == elcourse.ID).First();
elcourseAttached = _electiveCourseProducer.Get(new ElectiveCourse()
{
ID = elcourse.ID
});
//electiveCourses.UpdateValues(elcourseAttached, elcourse);
_electiveCourseProducer.Update(elcourse);
}
else
{
//if (electiveLists.Find(elcourse.electiveListID) != null)
if (_electiveListProducer.Get(new ElectiveList()
{
ID = elcourse.electiveListID
}) != null)
{
//electiveCourses.Add(elcourse);
//electiveCourses.SaveChanges();
_electiveCourseProducer.Create(elcourse);
//elcourseAttached = electiveCourses.Where(elc => elc.ID == elcourse.ID).First();
elcourseAttached = _electiveCourseProducer.Get(new ElectiveCourse()
{
ID = elcourse.ID
});
}
}
if (elcourseAttached != null)
{
degreeprogram.electiveCourses.Add(elcourseAttached);
}
}
//degreePrograms.UpdateValues(degreeAttached, degreeprogram);
//degreePrograms.SaveChanges();
_degreeProgramProducer.Update(degreeprogram);
return(RedirectToAction("Index"));
}
if (RequiredCourses != null)
{
foreach (RequiredCourse course in RequiredCourses)
{
if (course.courseID > 0)
{
//course.course = courses.Find(course.courseID);
course.course = _courseProducer.Get(new Course()
{
ID = course.courseID
});
}
}
}
degreeprogram.requiredCourses = RequiredCourses.ToList();
if (ElectiveCourses != null)
{
foreach (ElectiveCourse course in ElectiveCourses)
{
if (course.electiveListID > 0)
{
//course.electiveList = electiveLists.Find(course.electiveListID);
course.electiveList = _electiveListProducer.Get(new ElectiveList()
{
ID = course.electiveListID
});
}
}
}
degreeprogram.electiveCourses = ElectiveCourses.ToList();
return(View(degreeprogram));
}
public ActionResult MoveCourse(int ID, int semester, int order)
{
//PlanCourse pcourseAttached = planCourses.Find(ID);
PlanCourse pcourseAttached = _planCourseProducer.Get(new PlanCourse {
ID = ID
});
//Plan planAttached = plans.Find(pcourseAttached.planID);
Plan planAttached = pcourseAttached.plan;
if (webSecurity.CurrentUser.IsInRole("Advisor") || planAttached.userID == webSecurity.CurrentUserId)
{
//if (semesters.Find(semester) != null)
if (_semesterProducer.Get(new Semester()
{
ID = semester
}) != null)
{
int oldSemester = pcourseAttached.semesterID;
int oldOrder = pcourseAttached.order;
if (semester != oldSemester)
{
List <PlanCourse> moveUp = planAttached.planCourses.Where(s => s.semesterID == oldSemester).ToList();
//List<PlanCourse> moveUp =
foreach (PlanCourse pc in moveUp)
{
if (pc.order > oldOrder)
{
pc.order = pc.order - 1;
//planCourses.UpdateValues(pc, pc);
_planCourseProducer.Update(pc);
}
}
List <PlanCourse> moveDown = planAttached.planCourses.Where(s => s.semesterID == semester).ToList();
foreach (PlanCourse pc in moveDown)
{
if (pc.order >= order)
{
pc.order = pc.order + 1;
//planCourses.UpdateValues(pc, pc);
_planCourseProducer.Update(pc);
}
}
}
else
{
if (oldOrder < order)
{
List <PlanCourse> moveUp = planAttached.planCourses.Where(s => s.semesterID == oldSemester).ToList();
foreach (PlanCourse pc in moveUp)
{
if (pc.order > oldOrder && pc.order <= order)
{
pc.order = pc.order - 1;
//planCourses.UpdateValues(pc, pc);
_planCourseProducer.Update(pc);
}
}
}
else if (oldOrder > order)
{
List <PlanCourse> moveDown = planAttached.planCourses.Where(s => s.semesterID == oldSemester).ToList();
foreach (PlanCourse pc in moveDown)
{
if (pc.order >= order && pc.order < order)
{
pc.order = pc.order + 1;
//planCourses.UpdateValues(pc, pc);
_planCourseProducer.Update(pc);
}
}
}
}
pcourseAttached.semesterID = semester;
if (order < 7)
{
pcourseAttached.order = order;
}
else
{
pcourseAttached.order = 7;
}
//planCourses.UpdateValues(pcourseAttached, pcourseAttached);
//planCourses.SaveChanges();
_planCourseProducer.Update(pcourseAttached);
return(new HttpStatusCodeResult(HttpStatusCode.OK));
}
}
return(new HttpStatusCodeResult(HttpStatusCode.NotFound));
}
