Esempio n. 1
0
        // GET: Subjects/Details/5
        public async Task <IActionResult> Details(int?id)
        {
            if (id == null)
            {
                return(NotFound());
            }

            var subject = await _context.Subject
                          .Include(s => s.Professors)
                          .ThenInclude(set => set.Professor)
                          .Include(s => s.Reviews)
                          .ThenInclude(r => r.Author)
                          .Include(s => s.Reviews)
                          .ThenInclude(r => r.SubjectReviewTagSet)
                          .ThenInclude(set => set.SubjectReviewTag)
                          .Include(s => s.Reviews)
                          .ThenInclude(r => r.Comments)
                          .Include(s => s.SubjectTagSet)
                          .ThenInclude(s => s.SubjectTag)
                          .Include(s => s.Faculty)
                          .ThenInclude(f => f.University)
                          .ThenInclude(u => u.City)

                          .SingleOrDefaultAsync(m => m.ID == id);

            if (subject == null)
            {
                return(NotFound());
            }

            if (!subject.Validated && !await _authorizationService.AuthorizeAsync(User, "CanModerate"))
            {
                return(NotFound());
            }

            var diff       = calcDifficulty(subject.Reviews);
            var interes    = calcInterest(subject.Reviews);
            var usefulness = calcUsefulness(subject.Reviews);
            var total      = calcTotalGrade(subject.Reviews);

            var gradesDict = new Dictionary <string, GradeInfo>();

            gradesDict.Add(
                "Težina",
                new GradeInfo {
                Grade = diff
            }
                );

            gradesDict.Add(
                "Predavaèi",
                new GradeInfo {
                Grade = interes
            }
                );

            gradesDict.Add(
                "Korisnost",
                new GradeInfo {
                Grade = usefulness
            }
                );

            gradesDict.Add(
                "Ukupno",
                new GradeInfo {
                Grade = total
            }
                );


            var model = new SubjectDetailViewModel
            {
                ID                 = subject.ID,
                Name               = subject.Name,
                ShortName          = subject.ShortName,
                Faculty            = subject.Faculty,
                Reviews            = subject.Reviews.OrderBy(r => r.Points).Take(2).ToList(),
                Description        = subject.Description,
                Professors         = subject.Professors.Select(p => p.Professor).ToList(),
                SubjectTags        = subject.SubjectTagSet.Select(set => set.SubjectTag).ToList(),
                Validated          = subject.Validated,
                AvgDifficultyGrade = diff,
                AvgInterestGrade   = interes,
                AvgUsefulnessGrade = usefulness,
                AvgTotal           = total,
                Grades             = gradesDict
            };

            return(View(model));
        }
Esempio n. 2
0
        public IActionResult SubjectRankings(int sort = 4, int tag = -1)
        {
            var query = _context.Subject
                        .Include(s => s.Professors)
                        .ThenInclude(set => set.Professor)
                        .Include(s => s.Reviews)
                        .ThenInclude(r => r.Author)
                        .Include(s => s.Reviews)
                        .ThenInclude(r => r.SubjectReviewTagSet)
                        .ThenInclude(set => set.SubjectReviewTag)
                        .Include(s => s.Reviews)
                        .ThenInclude(r => r.Comments)
                        .Include(s => s.SubjectTagSet)
                        .ThenInclude(s => s.SubjectTag)
                        .Include(s => s.Faculty)
                        .ThenInclude(f => f.University)
                        .ThenInclude(u => u.City)
                        .AsNoTracking().Where(s => s.Reviews.Count > 0 && s.Validated).ToList();

            List <SubjectDetailViewModel> subjectList = new List <SubjectDetailViewModel>();

            foreach (var subject in query)
            {
                var tagList = subject.SubjectTagSet.Select(set => set.SubjectTagID).ToList();

                if (tag != -1 && !tagList.Contains(tag))
                {
                    continue;
                }

                var model = new SubjectDetailViewModel
                {
                    ID                 = subject.ID,
                    Name               = subject.Name,
                    ShortName          = subject.ShortName,
                    Faculty            = subject.Faculty,
                    Reviews            = subject.Reviews.OrderBy(r => r.Points).Take(2).ToList(),
                    Description        = subject.Description,
                    Professors         = subject.Professors.Select(p => p.Professor).ToList(),
                    SubjectTags        = subject.SubjectTagSet.Select(set => set.SubjectTag).ToList(),
                    Validated          = subject.Validated,
                    AvgDifficultyGrade = calcDifficulty(subject.Reviews),
                    AvgInterestGrade   = calcInterest(subject.Reviews),
                    AvgUsefulnessGrade = calcUsefulness(subject.Reviews),
                    AvgTotal           = calcTotalGrade(subject.Reviews),
                    Grades             = new Dictionary <string, GradeInfo>()
                };

                subjectList.Add(model);
            }

            System.Linq.Expressions.Expression <Func <SubjectDetailViewModel, object> > orderSelector = null;
            switch (sort)
            {
            case 1:
                orderSelector = d => d.AvgDifficultyGrade;
                break;

            case 2:
                orderSelector = d => d.AvgInterestGrade;
                break;

            case 3:
                orderSelector = d => d.AvgUsefulnessGrade;
                break;

            case 4:
                orderSelector = d => d.AvgTotal;
                break;

            default:
                orderSelector = d => d.AvgTotal;
                break;
            }

            var q      = subjectList.AsQueryable();
            var sorted = q.OrderByDescending(orderSelector).Take(10).ToList();

            var selectList = new SelectList(_context.SubjectTag, "ID", "Name");

            if (tag != -1)
            {
                var selected = selectList.Where(i => i.Value.Equals(tag.ToString())).First();
                selected.Selected = true;
            }

            ViewData["SubjectTag"] = selectList;
            return(View(new SubjectRankingViewModel {
                Subjects = sorted, tag = tag, sort = sort
            }));
        }
 /// <summary>
 /// SetSubjectObject
 /// </summary>
 /// <param name="target"></param>
 /// <param name="value"></param>
 internal static void SetSubjectObject(SubjectDetailView target, SubjectDetailViewModel value)
 {
     target.SetValue(SubjectObjectProperty, value);
 }