コード例 #1
0
 private IList <T> GetPaginatedItems <T>(IEnumerable <T> items,
                                         PaginationParametersBase paginationParameters)
 {
     return(items
            .Skip(paginationParameters.Offset ?? 0)
            .Take(paginationParameters.PageSize)
            .ToList());
 }
コード例 #2
0
        public PaginatedList(IEnumerable <T> items, int count, PaginationParametersBase paginationParameters)
        {
            PageIndex       = paginationParameters.PageIndex;
            TotalPages      = (int)Math.Ceiling(count / (double)paginationParameters.PageSize);
            NumberOfResults = count;

            AddRange(items);
        }
コード例 #3
0
        public async Task <IActionResult> OnGetAsync(int?pageIndex = null, int?offset = null)
        {
            if (!ModelState.IsValid || SearchKeyword.IsNullOrEmpty())
            {
                return(Page());
            }

            _paginationParameters = new PaginationParametersBase
            {
                PageSize = 20, PageIndex = pageIndex ?? 1, Offset = offset ?? 0
            };

            var(caseManagersToDisplay, count) =
                await _caseManagerSearchService.OrderAndPaginateQueryableAsync(SearchKeyword, _paginationParameters);

            CaseManagersSearchResults = new PaginatedList <User>(caseManagersToDisplay, count, _paginationParameters);

            if (CaseManagersSearchResults.HasNextPage)
            {
                NextPageUrl = QueryHelpers.AddQueryString("/ServiceDirectory/SearchResults",
                                                          new Dictionary <string, string>
                {
                    { "SearchKeyword", SearchKeyword },
                    { "pageIndex", (_paginationParameters.PageIndex + 1).ToString() },
                    { "offset", (_paginationParameters.Offset + caseManagersToDisplay.Count).ToString() }
                });
            }

            if (CaseManagersSearchResults.HasPreviousPage)
            {
                PreviousPageUrl = QueryHelpers.AddQueryString("/ServiceDirectory/SearchResults",
                                                              new Dictionary <string, string>
                {
                    { "SearchKeyword", SearchKeyword },
                    { "pageIndex", (_paginationParameters.PageIndex - 1).ToString() },
                    { "offset", (_paginationParameters.Offset - _paginationParameters.PageSize).ToString() }
                });
            }

            PrepareBreadcrumbs();

            return(Page());
        }
コード例 #4
0
        public async Task <(IList <User> caseManagers, int count)> OrderAndPaginateQueryableAsync(
            string searchKeyword,
            PaginationParametersBase paginationParameters)
        {
            var searchKeywords = searchKeyword.Split(" ")
                                 .Where(x => !x.IsNullOrEmpty())
                                 .Select(s => s.ToLower()).ToList();
            var caseManagers = await _referenceDataRepository.GetAllCaseManagersQueryable()
                               .ToListAsync();

            // This query is too complex to translate to sql, so we explicitly work on an in-memory list.
            // The size of the directory should make this ok.
            var filtered = caseManagers.Where(c =>
                                              searchKeywords.Any(s => c.FamilyName.ToLower().Contains(s)) ||
                                              searchKeywords.Any(s => c.GivenName.ToLower().Contains(s)) ||
                                              c.CaseManagerTbServices.Any(x =>
                                                                          searchKeywords.Any(s => x.TbService.Name.ToLower().Contains(s))))
                           .ToList();

            return(GetPaginatedItems(filtered, paginationParameters), filtered.Count);
        }
コード例 #5
0
        public (IList <ServiceDirectoryItemWrapper>, int) GetPaginatedItems(
            IList <PHEC> regions,
            IList <User> users,
            IList <TBService> tbServices,
            IList <Hospital> hospitals,
            PaginationParametersBase paginationParameters)
        {
            var serviceDirectoryItems = new List <ServiceDirectoryItemWrapper>();

            serviceDirectoryItems.AddRange(regions.Select(r => new ServiceDirectoryItemWrapper(r)));
            serviceDirectoryItems.AddRange(tbServices.Select(t => new ServiceDirectoryItemWrapper(t)));
            serviceDirectoryItems.AddRange(hospitals.Select(h => new ServiceDirectoryItemWrapper(h)));
            serviceDirectoryItems.AddRange(users.Select(u => new ServiceDirectoryItemWrapper(u)));

            var paginatedServiceDirectoryItems = serviceDirectoryItems
                                                 .Skip(paginationParameters.Offset ?? 0)
                                                 .Take(paginationParameters.PageSize)
                                                 .ToList();

            return(paginatedServiceDirectoryItems, serviceDirectoryItems.Count);
        }
コード例 #6
0
        public async Task <IActionResult> OnGetAsync(int?pageIndex = null, int?offset = null)
        {
            if (!ModelState.IsValid || SearchKeyword.IsNullOrEmpty())
            {
                return(Page());
            }

            _paginationParameters = new PaginationParametersBase
            {
                PageSize  = 20,
                PageIndex = pageIndex ?? 1,
                Offset    = offset ?? 0
            };

            var searchKeywords = SearchStringHelper.GetSearchKeywords(SearchKeyword);

            var usersToDisplay = await _userSearchService.OrderQueryableAsync(searchKeywords);

            var regionsToDisplay = await _referenceDataRepository.GetPhecsBySearchKeywords(searchKeywords);

            var tbServicesToDisplay = await _referenceDataRepository.GetActiveTBServicesBySearchKeywords(searchKeywords);

            var hospitalsToDisplay = await _referenceDataRepository.GetActiveHospitalsBySearchKeywords(searchKeywords);

            var(paginatedResults, count) =
                _serviceDirectoryService.GetPaginatedItems(
                    regionsToDisplay,
                    usersToDisplay,
                    tbServicesToDisplay,
                    hospitalsToDisplay,
                    _paginationParameters);

            DirectorySearchResults = new PaginatedList <ServiceDirectoryItemWrapper>(paginatedResults, count, _paginationParameters);

            AllPhecs = await _referenceDataRepository.GetAllPhecs();

            if (DirectorySearchResults.HasNextPage)
            {
                NextPageUrl = QueryHelpers.AddQueryString("/ServiceDirectory/SearchResults",
                                                          new Dictionary <string, string>
                {
                    { "SearchKeyword", SearchKeyword },
                    { "pageIndex", (_paginationParameters.PageIndex + 1).ToString() },
                    { "offset", (_paginationParameters.Offset + paginatedResults.Count).ToString() }
                });
            }

            if (DirectorySearchResults.HasPreviousPage)
            {
                PreviousPageUrl = QueryHelpers.AddQueryString("/ServiceDirectory/SearchResults",
                                                              new Dictionary <string, string>
                {
                    { "SearchKeyword", SearchKeyword },
                    { "pageIndex", (_paginationParameters.PageIndex - 1).ToString() },
                    { "offset", (_paginationParameters.Offset - _paginationParameters.PageSize).ToString() }
                });
            }

            PrepareBreadcrumbs();

            return(Page());
        }