Exemple #1
0
        public ActionResult Schedule()
        {
            GPFSession session = (GPFSession)TempData["GPFSession"];

            if (session == null)
            {
                return(RedirectToAction("Options", "GPF"));
            }

            session.Degree        = _degreeService.GetDegreeById(session.Degree.Id);
            session.Concentration = session.Degree.Concentrations.Find(x => x.Id == session.Concentration.Id);
            GPFSchedule schedule = _gpfService.GetSessionSchedule(session);

            GPFViewModel model = new GPFViewModel()
            {
                GPFSession  = session,
                GPFSchedule = schedule
            };

            return(View(model));
        }
        public GPFSchedule GetSessionSchedule(GPFSession session)
        {
            List <int>    toTake  = new List <int>();
            List <int>    missing = new List <int>();
            List <Course> temp;
            decimal       hours = 0;
            //add major courses based on session
            CourseService crsServ      = new CourseService();
            List <Course> majorCourses = crsServ.GetCoursesRequiredByDegree(session.Degree.Id);
            //populate course ids list from session
            List <Course> courseids = new List <Course>(session.ConcentrationCoursesSelected.Count + session.ElectiveCoursesSelected.Count + majorCourses.Count);

            courseids.AddRange(majorCourses);
            courseids.AddRange(session.ConcentrationCoursesSelected);
            courseids.AddRange(session.ElectiveCoursesSelected);
            //list of full course objects
            List <Course> courses = new List <Course>(courseids.Count);

            //Convert each course from an id to a full course object
            foreach (Course course in courseids)
            {
                courses.Add(crsServ.GetCoursesById(course.Id));
                toTake.Add(course.Id);
            }
            foreach (Course course in courses)
            {
                course.Prerequisites = crsServ.GetCoursePrereqs(course.Id);
                if (course.Prerequisites == null)
                {
                    course.Prerequisites = new List <Course>();
                }
            }
            //add any missing prereqs
            foreach (Course course in courses)
            {
                foreach (Course pre in course.Prerequisites)
                {
                    if (!toTake.Contains(pre.Id))
                    {
                        missing.Add(pre.Id);
                    }
                }
            }
            while (missing.Count > 0)
            {
                foreach (int misId in missing.ToArray())
                {
                    Course toAdd = crsServ.GetCoursesById(misId);
                    toAdd.Prerequisites = crsServ.GetCoursePrereqs(misId);
                    if (toAdd.Prerequisites == null)
                    {
                        toAdd.Prerequisites = new List <Course>();
                    }
                    courses.Add(toAdd);
                    toTake.Add(misId);
                    missing.Remove(misId);
                }
                foreach (Course course in courses)
                {
                    foreach (Course pre in course.Prerequisites)
                    {
                        if (!toTake.Contains(pre.Id))
                        {
                            missing.Add(pre.Id);
                        }
                    }
                }
            }
            //remove any duplicates
            temp = new List <Course>();
            foreach (Course course in courses)
            {
                if (!course.isContainedBy(temp))
                {
                    temp.Add(course);
                }
            }
            courses.Clear();
            courses.AddRange(temp);
            //determine number of hours being taken
            foreach (Course course in courses)
            {
                hours += course.Units;
            }
            //if less than 48 are being taken, add new concentration classes until at least 48 hours worth of classes are there
            if (hours < 48)
            {
                int           count  = 0;
                List <Course> extras = crsServ.GetCoursesByConcentration(session.Concentration.Id);
                foreach (Course course in extras)
                {
                    course.Prerequisites = crsServ.GetCoursePrereqs(course.Id);
                    if (course.Prerequisites == null)
                    {
                        course.Prerequisites = new List <Course>();
                    }
                }
                while (hours < 48)
                {
                    if (!extras[count].isContainedBy(courses) && extras[count].Prerequisites.Count == 0)
                    {
                        courses.Add(extras[count]);
                        toTake.Add(extras[count].Id);
                        hours += extras[count].Units;
                    }
                    count++;
                }
            }

            //add any missing prereqs
            foreach (Course course in courses)
            {
                foreach (Course pre in course.Prerequisites)
                {
                    if (!toTake.Contains(pre.Id))
                    {
                        missing.Add(pre.Id);
                    }
                }
            }
            while (missing.Count > 0)
            {
                foreach (int misId in missing.ToArray())
                {
                    Course toAdd = crsServ.GetCoursesById(misId);
                    toAdd.Prerequisites = crsServ.GetCoursePrereqs(misId);
                    if (toAdd.Prerequisites == null)
                    {
                        toAdd.Prerequisites = new List <Course>();
                    }
                    courses.Add(toAdd);
                    toTake.Add(misId);
                    missing.Remove(misId);
                }
                foreach (Course course in courses)
                {
                    foreach (Course pre in course.Prerequisites)
                    {
                        if (!toTake.Contains(pre.Id))
                        {
                            missing.Add(pre.Id);
                        }
                    }
                }
            }
            //remove any duplicates
            temp = new List <Course>();
            foreach (Course course in courses)
            {
                if (!course.isContainedBy(temp))
                {
                    temp.Add(course);
                }
            }
            courses.Clear();
            courses.AddRange(temp);
            //sort courses using tree
            CourseTree    tree          = new CourseTree(courses);
            List <Course> sortedCourses = tree.GetList();
            //get class history
            List <Course> taken    = crsServ.GetCourseHistory(session.Account.Id);
            GPFSchedule   schedule = new GPFSchedule(session, sortedCourses, taken);

            return(schedule);
        }