コード例 #1
0
        public async Task<ActionResult> Index([ModelBinder(typeof(SearchBinder))] SearchViewModel searchView)
        {
            var ratios = await db.CriterionRatios.Include(c=>c.CriterionSource).Include(c=>c.CriterionDestination).ToListAsync();
            var courses = await db.Courses.Include(c=>c.Exams).Include(c=>c.Institute).Include(c=>c.Discipline).Include(c=>c.Institute.District).ToListAsync();
            var calc = new Calculation(ratios);

            var filter = new CourseFilterProreties();
            filter.Budget = searchView.Budget;
            filter.Disciplines = searchView.Disciplines;
            filter.Districts = searchView.Districts;
            filter.Extrabudget = searchView.ExtraBudget;
            filter.PreparatoryCourses = searchView.PreparationCourses;
            filter.Exams = searchView.Exams;
            filter.Cost = searchView.Cost;
            filter.Hostel = searchView.Hostel;
            filter.LearningTypes=new List<LearningType>();
            if (searchView.FullTime)
            {
                filter.LearningTypes.Add(LearningType.FullTime);
            }
            if (searchView.DistanceLearning)
            {
                filter.LearningTypes.Add(LearningType.DistanceLearning);
            }

            var model = new SearchViewModel
            {
                CitiesSelectList = new List<SelectListItem>(),
                FindedCourses = new List<SearchCourseViewModel>(),
                DisciplinesSelectList = new List<SelectListItem>(),
                DistinctsSelectList = new List<SelectListItem>(),
                ExamsSelectList = new List<SelectListItem>()
            };

            foreach (var course in courses)
            {
                if(!filter.Disciplines.Any(d=>d.Id==course.Discipline.Id))
                    continue;
                var doubles=calc.GetCoefOfCourse(filter, course, courses); // ЗДЕСЬ ПРОИСХОДИТ РАСЧЕТ КОЭФФИЦИЕНТА ПО ДАННЫМ ФИЛЬТРА
                var searchCourseViewModel = new SearchCourseViewModel();
                searchCourseViewModel.Course = course;
                searchCourseViewModel.SearchCoef = doubles;
                model.FindedCourses.Add(searchCourseViewModel);
            }

            model.FindedCourses=model.FindedCourses.OrderBy(o => o.SearchCoef).Reverse().ToList();


            var cities = await db.Cities.ToListAsync();
            var districts = await db.Districts.ToListAsync();
            var disciplines = await db.Disciplines.ToListAsync();
            var exams = await db.Exams.ToListAsync();

            foreach (var city in cities)
            {
                var selectItem = new SelectListItem();
                selectItem.Text = city.Name;
                selectItem.Value = city.Id.ToString();
                model.CitiesSelectList.Add(selectItem);
            }

            foreach (var discipline in disciplines)
            {
                var selectItem = new SelectListItem();
                selectItem.Text = discipline.Name;
                selectItem.Value = discipline.Id.ToString();
                model.DisciplinesSelectList.Add(selectItem);
            }

            foreach (var district in districts)
            {
                var selectItem = new SelectListItem();
                selectItem.Text = district.Name;
                selectItem.Value = district.Id.ToString();
                model.DistinctsSelectList.Add(selectItem);
            }

            foreach (var exam in exams)
            {
                var selectItem = new SelectListItem();
                selectItem.Text = exam.Name;
                selectItem.Value = exam.ExamId.ToString();
                model.ExamsSelectList.Add(selectItem);
            }


            return View(model);
        }
コード例 #2
0
        /// <summary>
        ///     Функция, которая непосредственно рассчитывает критерий, на основе значений фильтра, для заданного конкретного направления подготовки
        /// </summary>
        /// <param name="filter">Параметры фильтра, которые отметил пользователь</param>
        /// <param name="course">Конкретное направление подгтовки, для которого расчитывается криетрий</param>
        /// <param name="allCourses">Список всех направлений подготовки. *** Он нам нужен, чтобы определить, есть ли в вузе другие направления, которые дополнительно отметил пользователь***  - если непонятно - напиши мне.</param>
        /// <returns></returns>
        public double GetCoefOfCourse(CourseFilterProreties filter, Course course, List<Course> allCourses)
        {
            double totalCoefficient = 0;
            //Критерий "Наличие специальности
            if (filter.Disciplines.Any(d => d.Id == course.Discipline.Id))
            {
                if (filter.Disciplines.Count == 1)
                {
                    totalCoefficient += Criteries.First(c => c.Name == "DisciplineExists").CriterionCoef;
                }
                else
                {
                    List<Course> instituteCourses = allCourses.Where(c => c.Institute.Id == course.Institute.Id).ToList();
                    int findedDisciplines =
                        filter.Disciplines.Count(discipline => instituteCourses.Any(i => i.Discipline.Id == discipline.Id));
                    double disciplinesCount = filter.Disciplines.Count;
                    totalCoefficient += (Criteries.First(c => c.Name == "DisciplineExists").CriterionCoef*
                                         (findedDisciplines/disciplinesCount));
                }
            }
            //Конец критерия "Наличие специальности

            //Критерий "Вступительные испытания
            if (filter.Exams.Count == 0)
            {
                totalCoefficient += Criteries.First(c => c.Name == "ExamsExists").CriterionCoef;
            }
            else
            {
                double findedExams = filter.Exams.Count(exam => course.Exams.Any(i => i.ExamId == exam.ExamId));
                double examsCount = course.Exams.Count;
                totalCoefficient += Criteries.First(c => c.Name == "ExamsExists").CriterionCoef*(findedExams/examsCount);
            }
            //Конец критерия "Вступительные испытания

            //Критерий "•	Наличие подготовительных курсов
            if (filter.PreparatoryCourses)
            {
                if (course.PreparatoryCourses)
                {
                    totalCoefficient += Criteries.First(c => c.Name == "PreparatoryCoursesExists").CriterionCoef;
                }
            }
            else
            {
                totalCoefficient += Criteries.First(c => c.Name == "PreparatoryCoursesExists").CriterionCoef;
            }
            //Конец критерия "•	Наличие подготовительных курсов

            //Критерий "•	Наличие общежития
            if (filter.Hostel)
            {
                if (course.Hostel)
                {
                    totalCoefficient += Criteries.First(c => c.Name == "HostelExists").CriterionCoef;
                }
            }
            else
            {
                totalCoefficient += Criteries.First(c => c.Name == "HostelExists").CriterionCoef;
            }
            //Конец критерия "•	Наличие общежития

            //Критерий "•	Бюджет/внебюджет
            if (!filter.Budget && !filter.Extrabudget)
            {
                totalCoefficient += Criteries.First(c => c.Name == "BudgetOrExtrabudget").CriterionCoef;
            }
            else if (filter.Budget && !filter.Extrabudget && course.Budget)
            {
                totalCoefficient += Criteries.First(c => c.Name == "BudgetOrExtrabudget").CriterionCoef;
            }
            else if (!filter.Budget && filter.Extrabudget && course.Extrabudgetary)
            {
                if (course.Cost <= filter.Cost)
                {
                    totalCoefficient += Criteries.First(c => c.Name == "BudgetOrExtrabudget").CriterionCoef;
                }
                else if (course.Cost <= filter.Cost - 15000)
                {
                    totalCoefficient += Criteries.First(c => c.Name == "BudgetOrExtrabudget").CriterionCoef*0.5;
                }
            }
            else if (filter.Budget && filter.Extrabudget)
            {
                if (course.Budget)
                {
                    totalCoefficient += Criteries.First(c => c.Name == "BudgetOrExtrabudget").CriterionCoef;
                }
                else if (course.Extrabudgetary && course.Cost <= filter.Cost)
                {
                    totalCoefficient += Criteries.First(c => c.Name == "BudgetOrExtrabudget").CriterionCoef*0.5;
                }
            }

            //Конец критерия "•	Бюджет/внебюджет

            //Критерий "•	Расположение
            if (filter.Districts.Count != 0)
            {
                if (course.Institute.District != null)
                {
                    if (filter.Districts.Count > 0 && filter.Districts.Any(d => d.Id == course.Institute.District.Id))
                    {
                        totalCoefficient += Criteries.First(c => c.Name == "CityLocation").CriterionCoef;
                    }
                }
            }
            else
            {
                totalCoefficient += Criteries.First(c => c.Name == "CityLocation").CriterionCoef;
            }
            //Конец критерия "•	Расположение

            //Критерий "•	Очное/ заочное
            if (filter.LearningTypes.Count == 0)
            {
                totalCoefficient += Criteries.First(c => c.Name == "LearningType").CriterionCoef;
            }
            else
            {

                if (filter.LearningTypes.Any(t => t == LearningType.FullTime) &&
                    filter.LearningTypes.All(t => t != LearningType.DistanceLearning) &&
                    course.LearningType == LearningType.FullTime)
                {
                    totalCoefficient += Criteries.First(c => c.Name == "LearningType").CriterionCoef;
                }
                else if (filter.LearningTypes.Any(t => t == LearningType.DistanceLearning) &&
                         filter.LearningTypes.All(t => t != LearningType.FullTime) &&
                         course.LearningType == LearningType.DistanceLearning)
                {
                    totalCoefficient += Criteries.First(c => c.Name == "LearningType").CriterionCoef;
                }
                else if (filter.LearningTypes.Any(t => t == LearningType.DistanceLearning) &&
                         filter.LearningTypes.All(t => t != LearningType.FullTime) &&
                         course.LearningType == LearningType.FullTime)
                {
                    totalCoefficient += Criteries.First(c => c.Name == "LearningType").CriterionCoef*0.3;
                }
                else if (filter.LearningTypes.Any(t => t == LearningType.FullTime) &&
                         filter.LearningTypes.Any(t => t == LearningType.DistanceLearning))
                {
                    totalCoefficient += Criteries.First(c => c.Name == "LearningType").CriterionCoef;
                }
            }
            //Конец критерия "•	Очное/ заочное

            return totalCoefficient;
        }