public ActionResult Create(DegreeProgram degreeprogram)
{
if (ModelState.IsValid)
{
//degreePrograms.Add(degreeprogram);
//degreePrograms.SaveChanges();
degreeprogram = _degreeProgramProducer.Create(degreeprogram).First();
degreeprogram = _degreeProgramProducer.Get(degreeprogram);
return RedirectToAction("Edit", new { id = degreeprogram.ID });
}
return View(degreeprogram);
}
public ActionResult Create(DegreeProgram degreeprogram)
{
if (ModelState.IsValid)
{
_request_queue.Send(MessageHandler.GetSerializableObject(typeof(DegreeProgram),degreeprogram,true), "Create - DegreePrograms");
return RedirectToAction("Edit", new { id = degreeprogram.ID });
}
return View(degreeprogram);
}
public ActionResult Edit(DegreeProgram degreeprogram, IEnumerable<RequiredCourse> RequiredCourses, IEnumerable<ElectiveCourse> ElectiveCourses)
{
if (ModelState.IsValid)
{
_request_queue.Send(degreeprogram.ID, "Details - DegreePrograms");
SerializableModels.DegreeProgram dp = (GetMessage(typeof(SerializableModels.DegreeProgram[])) as SerializableModels.DegreeProgram[])[0];
DegreeProgram degreeAttached = (DegreeProgram)MessageHandler.GetRegularObject(typeof(DegreeProgram), dp);
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))
{
_request_queue.Send(course.ID, "Details - RequiredCourses");
SerializableModels.RequiredCourse rc = (GetMessage(typeof(SerializableModels.RequiredCourse[])) as SerializableModels.RequiredCourse[])[0];
RequiredCourse reqcourseAttached = (RequiredCourse)MessageHandler.GetRegularObject(typeof(RequiredCourse), rc);
toRemove.AddFirst(reqcourseAttached);
}
}
}
//deletes those courses from the list
while(toRemove.Count > 0){
RequiredCourse removeme = toRemove.First();
toRemove.RemoveFirst();
_request_queue.Send(removeme.ID, "Delete - RequiredCourses");
}
//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)
{
_request_queue.Send(reqcourse.ID, "Details - RequiredCourses");
SerializableModels.RequiredCourse rc = (GetMessage(typeof(SerializableModels.RequiredCourse[])) as SerializableModels.RequiredCourse[])[0];
reqcourseAttached = (RequiredCourse)MessageHandler.GetRegularObject(typeof(RequiredCourse), rc);
requiredCourses.UpdateValues(reqcourseAttached, reqcourse);
}
else
{
_request_queue.Send(reqcourse.courseID, "Details - Courses");
SerializableModels.Course c = (GetMessage(typeof(SerializableModels.Course[])) as SerializableModels.Course[])[0];
Course course = (Course)MessageHandler.GetRegularObject(typeof(Course), c);
if (course != null)
{
_request_queue.Send(reqcourse, "Create - RequiredCourses");
_request_queue.Send(reqcourse.ID, "Details - RequiredCourses");
SerializableModels.RequiredCourse rc = (GetMessage(typeof(SerializableModels.RequiredCourse[])) as SerializableModels.RequiredCourse[])[0];
reqcourseAttached = (RequiredCourse)MessageHandler.GetRegularObject(typeof(RequiredCourse), rc);
}
}
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))
{
_request_queue.Send(course.ID, "Details - ElectiveCourses");
SerializableModels.ElectiveCourse ec = (GetMessage(typeof(SerializableModels.ElectiveCourse[])) as SerializableModels.ElectiveCourse[])[0];
ElectiveCourse elcourseAttached = (ElectiveCourse)MessageHandler.GetRegularObject(typeof(ElectiveCourse), ec);
toRemoveMe.AddFirst(elcourseAttached);
}
}
//remove those elective lists from the list
while (toRemoveMe.Count > 0)
{
ElectiveCourse removeme = toRemoveMe.First();
toRemoveMe.RemoveFirst();
_request_queue.Send(removeme, "Delete - ElectiveCourses");
}
//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)
{
_request_queue.Send(elcourse.ID, "Details - ElectiveCourses");
SerializableModels.ElectiveCourse ec = (GetMessage(typeof(SerializableModels.ElectiveCourse[])) as SerializableModels.ElectiveCourse[])[0];
elcourseAttached = (ElectiveCourse)MessageHandler.GetRegularObject(typeof(ElectiveCourse), ec);
electiveCourses.UpdateValues(elcourseAttached, elcourse);
}
else
{
_request_queue.Send(elcourse.ID, "Details - ElectiveLists");
SerializableModels.ElectiveList el = (GetMessage(typeof(SerializableModels.ElectiveList[])) as SerializableModels.ElectiveList[])[0];
ElectiveList electiveList = (ElectiveList)MessageHandler.GetRegularObject(typeof(ElectiveList), el);
if (electiveList != null)
{
_request_queue.Send(elcourse, "Create - ElectiveCourses");
_request_queue.Send(elcourse.ID, "Details - ElectiveCourses");
SerializableModels.ElectiveCourse ec = (GetMessage(typeof(SerializableModels.ElectiveCourse[])) as SerializableModels.ElectiveCourse[])[0];
elcourseAttached = (ElectiveCourse)MessageHandler.GetRegularObject(typeof(ElectiveCourse), ec);
}
}
if (elcourseAttached != null)
{
degreeprogram.electiveCourses.Add(elcourseAttached);
}
}
degreePrograms.UpdateValues(degreeAttached, degreeprogram);
degreePrograms.SaveChanges();
return RedirectToAction("Index");
}
if (RequiredCourses != null)
{
foreach (RequiredCourse course in RequiredCourses)
{
if (course.courseID > 0)
{
_request_queue.Send(course.courseID, "Details - Courses");
SerializableModels.Course c = (GetMessage(typeof(SerializableModels.Course[])) as SerializableModels.Course[])[0];
course.course = (Course)MessageHandler.GetRegularObject(typeof(Course), c);
}
}
}
degreeprogram.requiredCourses = RequiredCourses.ToList();
if (ElectiveCourses != null)
{
foreach (ElectiveCourse course in ElectiveCourses)
{
if (course.electiveListID > 0)
{
_request_queue.Send(course.electiveListID, "Details - ElectiveLists");
SerializableModels.ElectiveList el = (GetMessage(typeof(SerializableModels.ElectiveList[])) as SerializableModels.ElectiveList[])[0];
course.electiveList = (ElectiveList)MessageHandler.GetRegularObject(typeof(ElectiveList), el);
}
}
}
degreeprogram.electiveCourses = ElectiveCourses.ToList();
return View(degreeprogram);
}
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 static Object GetRegularObject(Type type, Object o, bool continueDeserializing = true)
{
Object return_object = null;
if (type == typeof(DegreeProgram))
{
SerializableModels.DegreeProgram dp = (SerializableModels.DegreeProgram) o;
DegreeProgram newItem = new DegreeProgram
{
ID = dp.ID,
degreeProgramName = dp.degreeProgramName,
degreeProgramDescription = dp.degreeProgramDescription,
};
if (dp.requiredCourses != null && dp.electiveCourses != null)
{
newItem.requiredCourses = new List<RequiredCourse>();
newItem.electiveCourses = new List<ElectiveCourse>();
foreach (SerializableModels.RequiredCourse rc in dp.requiredCourses)
{
newItem.requiredCourses.Add((RequiredCourse)GetRegularObject(typeof(RequiredCourse), rc, true));
}
foreach (SerializableModels.ElectiveCourse ec in dp.electiveCourses)
{
newItem.electiveCourses.Add((ElectiveCourse)GetRegularObject(typeof(ElectiveCourse), ec, true));
}
}
return_object = newItem;
}
else if (type == typeof(RequiredCourse))
{
SerializableModels.RequiredCourse rq = (SerializableModels.RequiredCourse) o;
RequiredCourse newItem = new RequiredCourse
{
ID = rq.ID,
courseID = rq.courseID,
degreeProgramID = rq.degreeProgramID,
semester = rq.semester,
};
newItem.course = (Course)GetRegularObject(typeof(Course), rq.course, true);
return_object = newItem;
}
else if (type == typeof(ElectiveCourse))
{
SerializableModels.ElectiveCourse eq = (SerializableModels.ElectiveCourse) o;
ElectiveCourse newItem = new ElectiveCourse
{
ID = eq.ID,
electiveListID = eq.electiveListID,
degreeProgramID = eq.degreeProgramID,
semester = eq.semester,
credits = eq.credits,
};
newItem.electiveList = (ElectiveList)GetRegularObject(typeof(ElectiveList), eq.electiveList, true);
return_object = newItem;
}
else if (type == typeof(Course))
{
SerializableModels.Course c = (SerializableModels.Course) o;
Course newItem = new Course
{
ID = c.ID,
coursePrefix = c.coursePrefix,
courseNumber = c.courseNumber,
courseTitle = c.courseTitle,
courseDescription = c.courseDescription,
minHours = c.minHours,
maxHours = c.maxHours,
undergrad = c.undergrad,
graduate = c.graduate,
variable = c.variable,
};
if (continueDeserializing)
{
List<PrerequisiteCourse> prereqsList = new List<PrerequisiteCourse>();
List<PrerequisiteCourse> prereqsForList = new List<PrerequisiteCourse>();
foreach (SerializableModels.PrerequisiteCourse pc in c.prerequisites)
{
prereqsList.Add((PrerequisiteCourse)GetRegularObject(typeof(PrerequisiteCourse), pc, true));
}
foreach (SerializableModels.PrerequisiteCourse pc in c.prerequisiteFor)
{
prereqsForList.Add((PrerequisiteCourse)GetRegularObject(typeof(PrerequisiteCourse), pc, true));
}
newItem.prerequisites = prereqsList.ToArray();
newItem.prerequisiteFor = prereqsForList.ToArray();
}
return_object = newItem;
}
else if (type == typeof(ElectiveList))
{
SerializableModels.ElectiveList eList = (SerializableModels.ElectiveList) o;
ElectiveList newItem = new ElectiveList
{
ID = eList.ID,
electiveListName = eList.electiveListName,
shortName = eList.shortName,
};
return_object = newItem;
}
else if (type == typeof(ElectiveListCourse))
{
SerializableModels.ElectiveListCourse elc = (SerializableModels.ElectiveListCourse) o;
ElectiveListCourse newItem = new ElectiveListCourse
{
ID = elc.ID,
courseID = elc.courseID,
electiveListID = elc.electiveListID,
course = (Course)GetRegularObject(typeof(Course), elc.course, true),
};
return_object = newItem;
}
else if (type == typeof(PrerequisiteCourse))
{
SerializableModels.PrerequisiteCourse pc = (SerializableModels.PrerequisiteCourse) o;
PrerequisiteCourse newItem = new PrerequisiteCourse
{
ID = pc.ID,
prerequisiteCourseID = pc.prerequisiteCourseID,
prerequisiteForCourseID = pc.prerequisiteForCourseID,
prerequisiteCourse = (Course)GetRegularObject(typeof(Course),pc.prerequisiteCourse,false),
prerequisiteForCourse = (Course)GetRegularObject(typeof(Course), pc.prerequisiteForCourse, false),
};
return_object = newItem;
}
else if (type == typeof(Plan))
{
SerializableModels.Plan plan = (SerializableModels.Plan) o;
Plan newItem = new Plan
{
ID = plan.ID,
planName = plan.planName,
degreeProgramID = plan.degreeProgramID,
userID = plan.userID,
semesterID = plan.semesterID,
semester = plan.semester,
};
if (continueDeserializing)
{
newItem.degreeProgram = (DegreeProgram)GetRegularObject(typeof(DegreeProgram), plan.degreeProgram, false);
newItem.user = (User)GetRegularObject(typeof(User), plan.user, true);
List<PlanCourse> planCourses = new List<PlanCourse>();
foreach (SerializableModels.PlanCourse planCourse in plan.planCourses)
{
planCourses.Add((PlanCourse)GetRegularObject(typeof(PlanCourse), planCourse, true));
}
newItem.planCourses = planCourses.ToArray();
}
return_object = newItem;
}
else if (type == typeof(User))
{
SerializableModels.User user = (SerializableModels.User) o;
User newItem = new User
{
ID = user.ID,
username = user.username,
realName = user.realName,
};
if (continueDeserializing && user.plans != null)
{
List<Plan> plans = new List<Plan>();
foreach (SerializableModels.Plan plan in user.plans)
{
plans.Add((Plan)GetRegularObject(typeof(Plan), plan, false));
}
}
return_object = newItem;
}
else if (type == typeof(PlanCourse))
{
SerializableModels.PlanCourse pc = (SerializableModels.PlanCourse) o;
PlanCourse newItem = new PlanCourse
{
ID = pc.ID,
notes = pc.notes,
planID = pc.planID,
courseID = pc.courseID,
electiveListID = pc.electiveListID,
semesterID = pc.semesterID,
order = pc.order,
semester = pc.semester,
credits = pc.credits,
};
if (continueDeserializing)
{
newItem.plan = (Plan)GetRegularObject(typeof(Plan), pc.plan, false);
if (pc.course.courseDescription != null)
{
newItem.course = (Course)GetRegularObject(typeof(Course), pc.course, true);
}
newItem.electiveList = (ElectiveList)GetRegularObject(typeof(ElectiveList), pc.electiveList, false);
}
return_object = newItem;
}
else
{
throw new NotImplementedException();
}
return return_object;
}
private DegreeProgram createTempDegreeProgram()
{
DegreeProgram temp = new DegreeProgram()
{
ID = 3,
degreeProgramName = "Degree Program 3",
requiredCourses = new Collection<RequiredCourse>(),
electiveCourses = new Collection<ElectiveCourse>(),
};
return temp;
}
