Ejemplo n.º 1
0
        public async Task <IActionResult> ShowRequests(RequestSearchQuery searchQuery)
        {
            _requestService.SetRequesterId(User.FindFirst(ClaimTypes.NameIdentifier).Value);

            if (User.FindFirst(ClaimTypes.Role).Value == "Student")
            {
                return(View("ShowStudentRequests", (await _requestService.GetRequestsForStudent()).Select(r => (RequestView)r)));
            }
            else if (User.FindFirst(ClaimTypes.Role).Value == "Professor")
            {
                PaginationView <RequestView, RequestSearchQuery> paginationView = new PaginationView <RequestView, RequestSearchQuery>
                {
                    TargetAction     = ControllerContext.RouteData.Values["action"].ToString(),
                    TargetController = ControllerContext.RouteData.Values["controller"].ToString(),
                    SearchQuery      = searchQuery
                };
                var serviceResult = await _requestService.GetAllRequestsForProfessor(searchQuery);

                paginationView.ObjectList = serviceResult.ObjectList.Select(e => (RequestView)e);
                paginationView.TotalCount = serviceResult.TotalCount;
                return(View("ShowProfessorRequests", paginationView));
            }
            else
            {
                return(BadRequest());
            }
        }
Ejemplo n.º 2
0
        public async Task <PaginationDTO <RequestDTO, RequestSearchQuery> > GetAllRequestsForProfessor(RequestSearchQuery query)
        {
            IQueryable <Request> queryBuilder = _context.Requests
                                                .Include(r => r.Thesis)
                                                .Include(r => r.Student)
                                                .Where(r => r.Thesis.Professor.Id == RequesterId);

            switch (query.OrderBy)
            {
            case RequestsOrderBy.DatePosted:
                queryBuilder = query.OrderAscending ? queryBuilder.OrderBy(x => x.DateCreated)
                        : queryBuilder.OrderByDescending(x => x.DateCreated);
                break;

            case RequestsOrderBy.ThesisId:
                queryBuilder = query.OrderAscending ? queryBuilder.OrderBy(x => x.ThesisId)
                        : queryBuilder.OrderByDescending(x => x.ThesisId);
                break;

            case RequestsOrderBy.Status:
                queryBuilder = query.OrderAscending ? queryBuilder.OrderBy(x => x.Status)
                        : queryBuilder.OrderByDescending(x => x.Status);
                break;
            }
            if (query.HideCompleted)
            {
                queryBuilder = queryBuilder.Where(x => x.Status == (int)RequestStatus.Pending);
            }

            PaginationDTO <RequestDTO, RequestSearchQuery> paginationResult = new PaginationDTO <RequestDTO, RequestSearchQuery>
            {
                TotalCount  = await queryBuilder.CountAsync(),
                SearchQuery = query
            };

            if (query.PerPage > 0)
            {
                queryBuilder = queryBuilder.Skip(query.PerPage * (query.Page - 1))
                               .Take(query.PerPage);
            }

            paginationResult.ObjectList = await queryBuilder.Select(e => (RequestDTO)e).ToArrayAsync();

            return(paginationResult);
        }