Exemple #1
0
        // GET: Students
        public async Task <IActionResult> Index(
            ListingFilterSortPageDto filterSortPageDto, [FromServices] IStudentService service)
        {
            PaginatedListDto <StudentListItem> paginatedList = null;

            try
            {
                paginatedList = await service.ListAllStudentssAsync(filterSortPageDto);

                // set the final page index based on the latest database records available
                filterSortPageDto.PageIndex = paginatedList.PageIndex;
            }
            catch (GeneralException ex)
            {
                _logger.LogError("GeneralException in Index: " + ex.Message);
                ViewBag.HasError = true;
                ViewBag.Message  = ex.Message;
            }
            catch (Exception ex)
            {
                _logger.LogError("Exception in Index: " + ex.Message);
                ViewBag.HasError = true;
                ViewBag.Message  = Constants.ERROR_MESSAGE_STANDARD + ": " + ex.Message;
            }

            var studentListDto = new StudentListDto
            {
                FilterSortPageValues = filterSortPageDto,
                Listing = paginatedList
            };

            return(View($"{_viewFolder}Index.cshtml", studentListDto));
        }
Exemple #2
0
        public async Task <PaginatedListDto <StudentListItem> > ListAllStudentssAsync(
            ListingFilterSortPageDto filterSortPageDto)
        {
            // call this first to:
            // - reset the PageNo by comparing the previous an current listing criteria
            filterSortPageDto.InitDto();

            var students = _context.Students
                           .Select(s => new StudentListItem
            {
                FirstMidName   = s.FirstMidName,
                LastName       = s.LastName,
                EnrollmentDate = s.EnrollmentDate,
                StudentId      = s.StudentId
            });

            StudentsFilterOptions filterBy = (StudentsFilterOptions)filterSortPageDto.FilterBy;
            var filterValue = filterSortPageDto.FilterValue;

            if (filterBy > 0 && !String.IsNullOrWhiteSpace(filterValue))
            {
                switch (filterBy)
                {
                case StudentsFilterOptions.FirstMidName:
                    students = students.Where(s => (s.FirstMidName.Contains(filterValue)));
                    break;

                case StudentsFilterOptions.LastName:
                    students = students.Where(s => (s.LastName.Contains(filterValue)));
                    break;

                case StudentsFilterOptions.EnrollmentDateAfter:
                    try
                    {
                        DateTime filterValueDate = DateTime.ParseExact(
                            filterValue, "yyyy-MM-dd", CultureInfo.CurrentCulture);
                        students = students.Where(s => (s.EnrollmentDate >= filterValueDate));
                    }
                    catch (Exception)
                    {
                        throw new GeneralException("Please enter a valid date value and retry.");
                    }
                    break;

                case StudentsFilterOptions.EnrollmentDateBefore:
                    try
                    {
                        DateTime filterValueDate = DateTime.ParseExact(
                            filterValue, "yyyy-MM-dd", CultureInfo.CurrentCulture);
                        students = students.Where(s => (s.EnrollmentDate <= filterValueDate));
                    }
                    catch (Exception)
                    {
                        throw new GeneralException("Please enter a valid date value and retry.");
                    }
                    break;
                }
            }

            // Order By
            StudentsSortByOptions sortBy = (StudentsSortByOptions)filterSortPageDto.SortBy;
            bool sortAscending           = filterSortPageDto.SortAscending;

            if (sortAscending)
            {
                students = students.OrderBy(e => EF.Property <object>(e, sortBy.ToString()));
            }
            else
            {
                students = students.OrderByDescending(e => EF.Property <object>(e, sortBy.ToString()));
            }

            PageSizeOptions pageSize  = (PageSizeOptions)filterSortPageDto.PageSize;
            var             pageIndex = filterSortPageDto.PageIndex;

            var paginatedList = await PaginatedListHelper <StudentListItem> .CreateAsync(
                students.AsNoTracking(), pageIndex, (int)pageSize);

            return(paginatedList);
        }