public Tuple <bool, STANDING> HasGraduated(Diploma diploma, Student student)
        {
            var credits         = 0;
            var average         = 0;
            var relevantCourses = 0;

            var requirements = diploma.Requirements.Select(x => Repository.GetRequirement(x));

            foreach (var requirement in requirements)
            {
                var studentCourse = student.Courses.FirstOrDefault(x => x.Id == requirement.Course);
                if (studentCourse != null)
                {
                    relevantCourses += 1;
                    average         += studentCourse.Mark;
                    if (studentCourse.Mark >= requirement.MinimumMark)
                    {
                        credits += requirement.Credits;
                    }
                }
            }

            average = average / relevantCourses;

            var standing = StandingsHelper.GetStandingFromMark(average);

            if (StandingsHelper.IsPassingGrade(average) && credits >= diploma.Credits)
            {
                return(new Tuple <bool, STANDING>(true, standing));
            }

            return(new Tuple <bool, STANDING>(false, standing));
        }
Beispiel #2
0
        public Tuple <bool, STANDING> HasGraduated(Diploma diploma, Student student)
        {
            var credits                = 0;
            int sumOfMarks             = 0;
            var requirementsForDiploma = diploma.Requirements;
            Dictionary <int, int> CoursesIDCreaditToPassList = new Dictionary <int, int>();

            foreach (var requiredId in requirementsForDiploma)
            {
                CoursesIDCreaditToPassList.Add(_repository.GetRequirement(requiredId).Courses[0], _repository.GetRequirement(requiredId).Credits);
            }

            List <int> CourseIDStudendHasPassed = new List <int>();

            foreach (var course in student.Courses)
            {
                CourseIDStudendHasPassed.Add(course.Id);
                sumOfMarks += course.Mark;
                credits    += CoursesIDCreaditToPassList.FirstOrDefault(x => x.Key == course.Id).Value;
            }

            if (CourseIDStudendHasPassed.All(CoursesIDCreaditToPassList.Keys.ToList().Contains) &&
                credits == diploma.Credits)
            {
                return(CalculateAverage(sumOfMarks, student.Courses.Length));
            }

            else
            {
                return(new Tuple <bool, STANDING>(false, STANDING.Remedial));
            }
        }
        public Tuple <bool, STANDING> HasGraduated(Diploma diploma, Student student)
        {
            int credits = 0, average = 0;

            for (int i = 0, j = 0; i < diploma.Requirements.Length && j < student.Courses.Length; i++, j++)
            {
                var requirement = Repository.GetRequirement(diploma.Requirements[i]);

                for (int k = 0; k < requirement.Courses.Length; k++)
                {
                    if (requirement.Courses[k] == student.Courses[j].Id)
                    {
                        average += student.Courses[j].Mark;
                        if (student.Courses[j].Mark > requirement.MinimumMark)
                        {
                            credits += requirement.Credits;
                        }
                    }
                }
            }
            average /= student.Courses.Length;


            STANDING standing;

            if (average < 50)
            {
                standing = STANDING.Remedial;
            }
            else if (average < 80)
            {
                standing = STANDING.Average;
            }
            else if (average < 95)
            {
                standing = STANDING.SumaCumLaude;
            }
            else
            {
                standing = STANDING.MagnaCumLaude;
            }

            switch (standing)
            {
            case STANDING.Remedial:
                return(new Tuple <bool, STANDING>(false, standing));

            case STANDING.Average:
                return(new Tuple <bool, STANDING>(true, standing));

            case STANDING.SumaCumLaude:
                return(new Tuple <bool, STANDING>(true, standing));

            case STANDING.MagnaCumLaude:
                return(new Tuple <bool, STANDING>(true, standing));

            default:
                return(new Tuple <bool, STANDING>(false, standing));
            }
        }
        public Tuple <bool, STANDING> HasGraduated(Diploma diploma, Student student)
        {
            var average = 0;

            foreach (var diplomaRequirement in diploma.Requirements)
            {
                var courseRequirement = Repository.GetRequirement(diplomaRequirement);
                var studentMark       = student.Courses.Single(c => c.Name == courseRequirement.Name).Mark;
                average += studentMark;
            }

            average /= student.Courses.Length;

            if (average < 50)
            {
                return(new Tuple <bool, STANDING>(false, STANDING.Remedial));
            }
            else if (average < 80)
            {
                return(new Tuple <bool, STANDING>(true, STANDING.Average));
            }
            else if (average < 95)
            {
                return(new Tuple <bool, STANDING>(true, STANDING.SumaCumLaude));
            }
            else
            {
                return(new Tuple <bool, STANDING>(true, STANDING.MagnaCumLaude));
            }
        }
Beispiel #5
0
        public ReportCard GetReportCard(Diploma diploma, Student student)
        {
            var result = new ReportCard()
            {
                DiplomaId = diploma.Id,
                StudentId = student.Id
            };
            var gradeSum = 0;
            var totalRequiredCoursesTakenForDiploma = 0;

            foreach (var requirementId in diploma.Requirements)
            {
                // Need to check if the student meets this requirement.
                var requirement = Repository.GetRequirement(requirementId);

                // Get all the courses the student has taken that are part of the requirement.
                var requirementCoursesTakenByStudent =
                    student.Courses.Where(c => requirement.CourseIds.Contains(c.Id));

                // Increment total number of courses taken for this diploma
                totalRequiredCoursesTakenForDiploma += requirementCoursesTakenByStudent.Count();

                // Aggregate the marks obtained.
                gradeSum += requirementCoursesTakenByStudent.Sum(c => c.Mark);

                // Aggregate credits if mark meets minimum requirement
                result.Credits += requirementCoursesTakenByStudent
                                  .Where(c => c.Mark > requirement.MinimumMark)
                                  .Sum(c => requirement.Credits);
            }

            result.Average = gradeSum / totalRequiredCoursesTakenForDiploma;

            return(result);
        }
        public Tuple <bool, Standing> HasGraduated(Diploma diploma, Student student)
        {
            int average = 0;

            CalculateAverage(diploma, student, ref average);
            return(CheckGraduation(average));
        }
        private static int CalculateAverage(Diploma diploma, Student student)
        {
            int average = 0;

            for (int i = 0; i < diploma.Requirements.Length; i++)
            {
                for (int j = 0; j < student.Courses.Length; j++)
                {
                    var requirement = Repository.GetRequirement(diploma.Requirements[i]);

                    for (int k = 0; k < requirement.Courses.Length; k++)
                    {
                        if (requirement.Courses[k] == student.Courses[j].Id)
                        {
                            average += student.Courses[j].Mark;

                            if (student.Courses[j].Mark >= requirement.MinimumMark)
                            {
                                student.Credits += requirement.Credits;
                            }
                        }
                    }
                }
            }

            return(average);
        }
Beispiel #8
0
        public static Diploma GetDiploma(int id)
        {
            var diplomas = GetDiplomas();
            IGraduation <Diploma> obj = new Diploma();

            return(obj.GetObjectByID(diplomas, id));
        }
        public Standing HasGraduated(Diploma diploma, Student student)
        {
            foreach (Requirement req in diploma.Requirements)
            {
                bool requirementMet = _requirementsService.CreditsFulfilled(req, student);
                if (!requirementMet)
                {
                    return(Standing.CreditsUnfulfilled);
                }
            }

            // Here I am making an assumption. I don't have enough information
            // on how the average is calculated. The original code is rather confusing:
            // it first totals the marks of the cources which ARE on the requirement but
            // then it divides that total by the number of cources the student completed
            // You have to pick one or the other: either compute the average of all cources the
            // student took OR compute the average of the REQUIRED cources. I picked the total
            // of the student completed cources
            int average = _requirementsService.GetStudentAverage(student);

            if (average < 50)
            {
                return(Standing.Remedial);
            }
            if (average < 80)
            {
                return(Standing.Average);
            }
            if (average < 95)
            {
                return(Standing.MagnaCumLaude);
            }

            return(Standing.MagnaCumLaude);
        }
Beispiel #10
0
        /// <summary>
        /// This Method based on Average checks whether the student is graduated or not.
        /// </summary>
        /// <param name="diploma"></param>
        /// <param name="student"></param>
        /// <returns>tuple of whether graduated and standing</returns>
        public Tuple <bool, STANDING> HasGraduated(Diploma diploma, Student student)
        {
            var credits      = 0;
            var average      = 0;
            int totalCourses = 0;

            for (int i = 0; i < diploma.Requirements.Length; i++)
            {
                var requirement = repository.GetRequirement(diploma.Requirements[i]);
                var requiredCoursesCompleted = student.Courses.Where(c => requirement.Courses.Contains(c.Id));
                average     += requiredCoursesCompleted.Sum(c => c.Mark);
                credits     += requiredCoursesCompleted.Where(rcp => rcp.Mark > requirement.MinimumMark).Count() * requirement.Credits;
                totalCourses = requirement.Courses.Count();
            }
            average = average / totalCourses;

            // No Case for STANDING.SumaCumLaude defined: requirement not clear
            if (average < 50)
            {
                return(new Tuple <bool, STANDING>(false, STANDING.Remedial));
            }
            else if (average < 80)
            {
                return(new Tuple <bool, STANDING>(true, STANDING.Average));
            }
            else if (average < 95)
            {
                return(new Tuple <bool, STANDING>(true, STANDING.MagnaCumLaude));
            }
            else
            {
                return(new Tuple <bool, STANDING>(false, STANDING.MagnaCumLaude));
            }
        }
        public Tuple <bool, STANDING> HasGraduated(Diploma diploma, Student student)
        {
            try
            {
                var creditsAverage = GetCreditAverage(diploma, student);
                var standing       = GetStanding(creditsAverage.Item2);

                // Not enough credits
                if (creditsAverage.Item1 < diploma.Credits)
                {
                    return(new Tuple <bool, STANDING>(false, STANDING.Remedial));
                }
                else if (standing == STANDING.Remedial || standing == STANDING.None)
                {
                    return(new Tuple <bool, STANDING>(false, standing));
                }
                else
                {
                    return(new Tuple <bool, STANDING>(true, standing));
                }
            }
            catch (Exception ex)
            {
                return(new Tuple <bool, STANDING>(false, STANDING.None));
            }
        }
Beispiel #12
0
        /// <summary>
        ///
        /// </summary>
        /// <param name="diploma"></param>
        /// <param name="student"></param>
        /// <returns></returns>
        public Tuple <bool, STANDING, int> HasGraduated(Diploma diploma, Student student)
        {
            var credits    = 0;
            var sumOfMarks = 0;

            for (int i = 0; i < diploma.Requirements.Length; i++)
            {
                for (int j = 0; j < student.Courses.Length; j++)
                {
                    var requirement = _repository.GetRequirement(diploma.Requirements[i]);

                    for (int k = 0; k < requirement.Courses.Length; k++)
                    {
                        if (requirement.Courses[k] == student.Courses[j].Id)
                        {
                            sumOfMarks += student.Courses[j].Mark;
                            if (student.Courses[j].Mark > requirement.MinimumMark)
                            {
                                credits += requirement.Credits;
                            }
                        }
                    }
                }
            }

            var averageMark = sumOfMarks / student.Courses.Length;

            //credits added to have ability to create unit test
            return(new Tuple <bool, STANDING, int>(StudentHasGraduated(averageMark), StudentStanding(averageMark), credits));
        }
Beispiel #13
0
        private void UpdateCredits(Diploma diploma, Student student, ref int credits, ref int average, IRepository repo)
        {
            try
            {
                for (int i = 0; i < diploma.Requirements.Length; i++)
                {
                    for (int j = 0; j < student.Courses.Length; j++)
                    {
                        var requirement = repo.GetRequirement(diploma.Requirements[i]);

                        for (int k = 0; k < requirement.Courses.Length; k++)
                        {
                            if (requirement.Courses[k] == student.Courses[j].Id)
                            {
                                average += student.Courses[j].Mark;
                                if (student.Courses[j].Mark > requirement.MinimumMark)
                                {
                                    credits += requirement.Credits;
                                }
                            }
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                _logger.LogError(ex.Message.ToString());
            }
        }
        private static float GetAverage(Diploma Diploma, Student Student)
        {
            int   Credits = 0;
            float Marks   = 0;

            for (int i = 0; i < Diploma.Requirements.Length; i++)
            {
                for (int j = 0; j < Student.Courses.Length; j++)
                {
                    Requirement Requirement = Requirement.GetRequirement(Diploma.Requirements[i]);

                    for (int k = 0; k < Requirement.Courses.Length; k++)
                    {
                        if (Requirement.Courses[k] == Student.Courses[j].Id)
                        {
                            Marks += Student.Courses[j].Mark;
                            if (Student.Courses[j].Mark > Requirement.MinimumMark)
                            {
                                Credits += Requirement.Credits;
                            }
                        }
                    }
                }
            }

            return(Marks / Student.Courses.Length);
        }
        public Tuple <bool, STANDING> HasGraduated(Diploma diploma, Student student)
        {
            var credits = 0;
            var average = 0;

            for (int i = 0; i < diploma.Requirements.Length; i++)
            {
                for (int j = 0; j < student.Courses.Length; j++)
                {
                    var requirement = _appIRepository.GetRequirement(diploma.Requirements[i]);


                    for (int k = 0; k < requirement.Courses.Length; k++)
                    {
                        if (requirement.Courses[k] == student.Courses[j].Id)
                        {
                            average += student.Courses[j].Mark;
                            if (student.Courses[j].Mark > requirement.MinimumMark)
                            {
                                credits += requirement.Credits;
                            }
                        }
                    }
                }
            }

            average = average / student.Courses.Length;
            return(GetStanding(average));
        }
Beispiel #16
0
        /// <summary>
        /// Function calculates average of student and provides an appropriate standing based on the result
        /// </summary>
        /// <param name="diploma">Contains the IDs of Required Courses</param>
        /// <param name="student">Contains List of Courses the Student Undertook</param>
        /// <returns>A tuple value that contains a boolean value and the standing</returns>
        public Tuple <bool, Standing> HasGraduated(Diploma diploma, Student student)
        {
            //Removed the variable "credits" as it wasn't used anywhere in the program.
            var average = 0;

            //Performed validations before executing the Expression to avoid any exceptions
            if (diploma != null && student != null && !student.Courses.Count().Equals(0))
            {
                average = diploma.Requirements.Where(requirementId =>
                                                     new Repository <RequirementRepository>().FetchRecordByID(requirementId) != null)
                          .Select(requirementId =>
                                  student.Courses.Where(courseSelector =>
                                                        courseSelector.Id.Equals(requirementId))
                                  .Select(courseSelector => courseSelector.Mark)
                                  .Sum()).Sum() / student.Courses.Count();
            }
            //Renamed and Moved the "GetRequirement" function above the Student Loop to reduce the amount of database call
            //Adding the marks of the course selector imperatively as all the conditions statisfy and perform an average

            //Removed unecessary "standing" variable as the same can be achieved by directly accessing the enum-constant
            return
                (average == 0 ? new Tuple <bool, Standing>(false, Standing.None) :
                 average < 50 ? new Tuple <bool, Standing>(false, Standing.Remedial) :
                 average < 80 ? new Tuple <bool, Standing>(true, Standing.Average) :
                 average < 95 ? new Tuple <bool, Standing>(true, Standing.MagnaCumLaude) :
                 new Tuple <bool, Standing>(true, Standing.SumaCumLaude));
        }
        public Diploma GetDiploma(int id)
        {
            var diplomas = GetDiplomas();

            Diploma diploma = diplomas.SingleOrDefault(x => x.Id == id);

            return(diploma);
        }
        public static Tuple <bool, STANDING> HasGraduated(Diploma diploma, Student student)
        {
            int  average          = CalculateAverage(diploma, student) / student.Courses.Length;
            bool reqCreditsEarned = RequiredCreditsEarned(diploma, student);

            student.Standing = DetermineStanding(average, reqCreditsEarned);

            return(new Tuple <bool, STANDING>(reqCreditsEarned && student.Standing > STANDING.Remedial, student.Standing));
        }
Beispiel #19
0
        public Tuple <bool, STANDING> HasGraduated(Diploma diploma, Student student)
        {
            Tuple <bool, STANDING> result = new Tuple <bool, STANDING>(false, STANDING.None);

            if (diploma == null || student == null || diploma.Requirements == null)
            {
                return(result);
            }

            var credits            = 0;
            int totalMarks         = 0;
            var courseRequirements = repository.GetCourseRequirements();

            for (int i = 0; i < diploma.Requirements.Length; i++)
            {
                var courseRequirement = courseRequirements.Where(cr => cr.Id == diploma.Requirements[i]).FirstOrDefault();
                if (courseRequirement == null)
                {
                    continue;
                }

                var courseMark = student.CourseMarks.Where(m => m.CourseId == courseRequirement.CourseId).FirstOrDefault();
                if (courseMark == null)
                {
                    continue;
                }

                totalMarks += courseMark.Mark;

                if (courseMark.Mark > courseRequirement.MinimumMark)
                {
                    credits += courseRequirement.Credits;
                }
            }

            var average = totalMarks / student.CourseMarks.Length;

            if (average < 50)
            {
                result = new Tuple <bool, STANDING>(false, STANDING.Remedial);
            }
            else if (average < 80)
            {
                result = new Tuple <bool, STANDING>(true, STANDING.Average);
            }
            else if (average < 95)
            {
                result = new Tuple <bool, STANDING>(true, STANDING.MagnaCumLaude);
            }
            else
            {
                result = new Tuple <bool, STANDING>(true, STANDING.SumaCumLaude);
            }

            return(result);
        }
        /// <summary>
        /// Check if the Student has been graduated
        /// </summary>
        /// <param name="diploma">Diploma to match with student courses</param>
        /// <param name="student">Student information</param>
        /// <returns>Tuple informing has graduated/Standing/Credits</returns>
        public Tuple <bool, STANDING, int> HasGraduated(Diploma diploma, Student student)
        {
            bool graduated = false;
            int  credits   = 0;
            var  average   = 0;

            foreach (Requirement iDipReq in diploma.Requirements)
            {
                //Get the diploma's requirement
                Requirement reqCourse = BRequirement.GetRequirement(iDipReq.Id);

                foreach (Course iStuCou in student.Courses)
                {
                    //Check if the current student course belongs to the diploma's requirement course
                    if (reqCourse.Courses.SingleOrDefault(x => x.Id == iStuCou.Id) != null)
                    {
                        average += iStuCou.Mark;

                        if (iStuCou.Mark > reqCourse.MinimumMark)
                        {
                            credits += reqCourse.Credits;
                        }
                    }
                }
            }

            average = average / student.Courses.Count;

            var standing = STANDING.None;

            if (average < 50)
            {
                standing  = STANDING.Remedial;
                graduated = false;
            }
            else if (average < 80)
            {
                standing  = STANDING.Average;
                graduated = true;
            }
            else if (average < 95)
            {
                standing  = STANDING.MagnaCumLaude;
                graduated = true;
            }
            else
            {
                standing  = STANDING.MagnaCumLaude;
                graduated = true;
            }

            return(new Tuple <bool, STANDING, int>(graduated, standing, credits));
        }
        public Tuple <bool, STANDING> HasGraduated(Diploma diploma, Student student)
        {
            // Ensure that all requirements are met
            var meetsRequirements = diploma.Requirements.All(rId => CoursesMeetRequirement(rId, student.Courses));

            // Calculate average grade and total credits
            var credits = 0;
            var average = 0;

            foreach (var course in student.Courses)
            {
                // Only passed courses count toward total credits
                if (course.Mark >= 50)
                {
                    credits += course.Credits;
                }
                // All courses count toward average
                average += course.Mark;
            }
            average = average / student.Courses.Length;

            var standing = STANDING.None;

            if (average >= 100)
            {
                standing = STANDING.SumaCumLaude;
            }
            else if (average >= 80)
            {
                standing = STANDING.MagnaCumLaude;
            }
            else if (average >= 50)
            {
                standing = STANDING.Average;
            }
            else
            {
                standing = STANDING.Remedial;
            }

            // In order to graduate a student must:
            // 1. have the minimum average grade (>=50)
            // 2. AND have met all of the specified requirements
            // 3. AND have earned the minimum number of credits
            var graduated = (
                standing != STANDING.Remedial &&
                meetsRequirements &&
                credits >= diploma.Credits
                );

            return(new Tuple <bool, STANDING>(graduated, standing));
        }
Beispiel #22
0
        public static Diploma GetDiploma(int id)
        {
            var     diplomas = GetDiplomas();
            Diploma diploma  = null;

            for (int i = 0; i < diplomas.Length; i++)
            {
                if (id == diplomas[i].Id)
                {
                    diploma = diplomas[i];
                }
            }
            return(diploma);
        }
Beispiel #23
0
        public static Diploma GetDiploma(int Id)
        {
            Diploma[] Diplomas = Repository.GetDiplomas();
            Diploma   Diploma  = null;

            for (int i = 0; i < Diplomas.Length; i++)
            {
                if (Id == Diplomas[i].Id)
                {
                    Diploma = Diplomas[i];
                }
            }
            return(Diploma);
        }
        public ResultGraduationTraker HasGraduated(Diploma diploma, Student student)
        {
            IEnumerable <RequirementCoursesMark> requirementCoursesMark = this.GetRequirementCoursesMarkData(diploma, student);
            decimal averageMark = this.GetAvarageMark(requirementCoursesMark, student);
            int     totalCredit = this.GetTotalCredit(requirementCoursesMark);

            student.Standing = this.GetStudentStanding(averageMark);

            return(new ResultGraduationTraker {
                Graduated = this.IsGraduated(student.Standing),
                Standing = student.Standing,
                TotalCredits = totalCredit
            });
        }
Beispiel #25
0
        public Tuple <bool, Standing> HasGraduated(Diploma diploma, Student student)
        {
            var average      = 0;
            var countCourses = 0;
            var requirements = diploma.Requirements;

            for (int i = 0; i < requirements.Length; i++)
            {
                var requirement = repository.GetRequirement(requirements[i]);
                average     += student.Courses.Where(c => requirement.Courses.Contains(c.Id)).Sum(c => c.Mark);
                countCourses = requirement.Courses.Count();
            }

            return(CalculateStanding(average / countCourses));
        }
Beispiel #26
0
        /// <summary>
        /// To check if a student has graduated; determined by the student standing
        /// </summary>
        /// <param name="diploma">The diploma object</param>
        /// <param name="student">The student object</param>
        /// <returns>A 3-Tuple</returns>
        public Tuple <bool, STANDING, int> HasGraduated(Diploma diploma, Student student)
        {
            var credits = 0;
            var average = 0;

            // get student's average
            average = GetStudentAverage(student, diploma.Requirements, out credits);

            // get student standing with the calculated average
            var standing = GetStandingByAverage(average);

            var graduated = (standing == STANDING.Average || standing == STANDING.SumaCumLaude || standing == STANDING.MagnaCumLaude) ? true : false;

            return(new Tuple <bool, STANDING, int>(graduated, standing, credits));
        }
Beispiel #27
0
        /// <summary>
        /// This function computes a student's average score and total credits for a given diploma program
        /// </summary>
        /// <param name="student"></param>
        /// <param name="diploma"></param>
        /// <param name="diplomareqId"></param>
        public void getStudentReqCreditsandAverage(Student student, Diploma diploma, int diplomareqId)
        {
            foreach (var stdcourse in student.Courses)
            {
                var requirement = Repository.GetRequirement(diplomareqId);

                foreach (int reqcourseId in requirement.Courses)
                {
                    if (requirement.Courses.Contains(stdcourse.Id))
                    {
                        average += stdcourse.Mark;
                        credits += stdcourse.Mark > requirement.MinimumMark ? requirement.Credits : 0;
                    }
                }
            }
        }
        public static Diploma GetDiploma(int id)
        {
            var     diplomas = GetDiplomas();
            Diploma diploma  = null;

            diploma = diplomas.FirstOrDefault(d => d.Id.Equals(id));

            //for (int i = 0; i < diplomas.Length; i++)
            //{
            //    if (id == diplomas[i].Id)
            //    {
            //        diploma = diplomas[i];
            //    }
            //}
            return(diploma);
        }
Beispiel #29
0
        public Tuple <bool, Standing> HasGraduated(Diploma diploma, Student student)
        {
            int credits = 0;
            var average = 0;

            for (int i = 0; i < diploma.Requirements.Length; i++)
            {
                for (int j = 0; j < student.Courses.Length; j++)
                {
                    Requirement requirement = RequirementRepository.GetById(diploma.Requirements[i]);

                    for (int k = 0; k < requirement.Courses.Length; k++)
                    {
                        if (requirement.Courses[k] == student.Courses[j].Id)
                        {
                            average += student.Courses[j].Mark;
                            if (student.Courses[j].Mark > requirement.MinimumMark)
                            {
                                credits += requirement.Credits;
                            }
                        }
                    }
                }
            }

            average /= student.Courses.Length;

            Standing standing = GetStanding(average);

            switch (standing)
            {
            case Standing.Remedial:
                return(new Tuple <bool, Standing>(false, standing));

            case Standing.Average:
                return(new Tuple <bool, Standing>(true, standing));

            case Standing.SumaCumLaude:
                return(new Tuple <bool, Standing>(true, standing));

            case Standing.MagnaCumLaude:
                return(new Tuple <bool, Standing>(true, standing));

            default:
                return(new Tuple <bool, Standing>(false, standing));
            }
        }
Beispiel #30
0
        public Tuple <bool, STANDING> HasGraduated(Diploma diploma, Student student)
        {
            credits = 0;
            average = 0;

            //calculate student credits and average score for each diploma requirement
            diploma.Requirements.ToList().ForEach(x => getStudentReqCreditsandAverage(student, diploma, x));
            average = average / student.Courses.Length;

            var standing = STANDING.None;

            if (average < 50)
            {
                standing = STANDING.Remedial;
            }
            else if (average < 80)
            {
                standing = STANDING.Average;
            }
            else if (average < 95)
            {
                standing = STANDING.MagnaCumLaude;
            }
            else
            {
                standing = STANDING.SumaCumLaude;
            }

            switch (standing)
            {
            case STANDING.Remedial:
                return(new Tuple <bool, STANDING>(false, standing));

            case STANDING.Average:
                return(new Tuple <bool, STANDING>(true, standing));

            case STANDING.SumaCumLaude:
                return(new Tuple <bool, STANDING>(true, standing));

            case STANDING.MagnaCumLaude:
                return(new Tuple <bool, STANDING>(true, standing));

            default:
                return(new Tuple <bool, STANDING>(false, standing));
            }
        }