public async Task <IActionResult> OnGetAsync(int?pageNumber, string searchTerm, string fundingPeriodId = null)
        {
            await PopulatePeriods(fundingPeriodId);

            if (string.IsNullOrWhiteSpace(fundingPeriodId))
            {
                fundingPeriodId = FundingPeriods.First().Value;
            }

            SearchRequestViewModel searchRequest = new SearchRequestViewModel()
            {
                PageNumber    = pageNumber,
                IncludeFacets = false,
                SearchTerm    = searchTerm,
                Filters       = new Dictionary <string, string[]> {
                    { "fundingPeriodId", new[] { fundingPeriodId } }
                }
            };

            SearchTerm = searchTerm;

            SearchResults = await _datasetRelationshipsSearchService.PerformSearch(searchRequest);

            if (SearchResults == null)
            {
                return(new StatusCodeResult(500));
            }

            return(Page());
        }
        public async Task <SpecificationDatasourceRelationshipSearchResultViewModel> PerformSearch(SearchRequestViewModel request)
        {
            var filters = request.Filters.IsNullOrEmpty()
                        ? new ConcurrentDictionary <string, string[]>()
                        : request.Filters;

            if (filters.ContainsKey(""))
            {
                filters.Remove("");
            }

            SearchFilterRequest requestOptions = new SearchFilterRequest()
            {
                Page          = request.PageNumber.HasValue ? request.PageNumber.Value : 1,
                PageSize      = request.PageSize.HasValue ? request.PageSize.Value : 50,
                SearchTerm    = request.SearchTerm,
                IncludeFacets = request.IncludeFacets,
                Filters       = filters
            };

            if (request.PageNumber.HasValue && request.PageNumber.Value > 0)
            {
                requestOptions.Page = request.PageNumber.Value;
            }

            PagedResult <SpecificationDatasourceRelationshipSearchResultItem> pagedResult = await _specsClient.FindSpecificationAndRelationships(requestOptions);

            if (pagedResult == null)
            {
                _logger.Error("Find specification data source relationships HTTP request failed");
            }

            int totalPages = pagedResult.TotalItems / pagedResult.PageSize;

            if (pagedResult.TotalItems % pagedResult.PageSize > 0)
            {
                totalPages++;
            }

            int startNumber = ((pagedResult.PageSize * pagedResult.PageNumber) - pagedResult.PageSize) + 1;
            int endNumber   = (pagedResult.PageSize * pagedResult.PageNumber);

            if (endNumber > pagedResult.TotalItems)
            {
                endNumber = pagedResult.TotalItems;
            }

            SpecificationDatasourceRelationshipSearchResultViewModel viewModel =
                new SpecificationDatasourceRelationshipSearchResultViewModel
            {
                Items           = pagedResult.Items,
                PagerState      = new PagerState(pagedResult.PageNumber, pagedResult.TotalPages),
                TotalCount      = pagedResult.TotalItems,
                StartItemNumber = startNumber,
                EndItemNumber   = endNumber
            };

            return(viewModel);
        }
        public async Task<IActionResult> SearchDatasetRelationships([FromBody] SearchRequestViewModel request)
        {
            Guard.ArgumentNotNull(request, nameof(request));

            SpecificationDatasourceRelationshipSearchResultViewModel result = await _searchService.PerformSearch(request);
            if (result != null)
            {
                return Ok(result);
            }
            else
            {
                return new StatusCodeResult(500);
            }
        }
        public async Task OnGetAsync_GivenSearchResultsReturnsResults_ReturnsPage()
        {
            // Arrange
            IEnumerable <Reference> fundingPeriods = new[]
            {
                new Reference {
                    Id = "1819", Name = "1018/19"
                }
            };

            ApiResponse <IEnumerable <Reference> > apiResponse = new ApiResponse <IEnumerable <Reference> >(HttpStatusCode.OK, fundingPeriods);

            ISpecsApiClient specsApiClient = CreateApiClient();

            specsApiClient
            .GetFundingPeriods()
            .Returns(apiResponse);

            SpecificationDatasourceRelationshipSearchResultViewModel model = new SpecificationDatasourceRelationshipSearchResultViewModel();

            IDatasetRelationshipsSearchService searchService = CreateSearchService();

            searchService
            .PerformSearch(Arg.Any <SearchRequestViewModel>())
            .Returns(model);

            DatasetRelationshipsPageModel pageModel = CreatePageModel(specsApiClient, searchService);

            // Act
            IActionResult actionResult = await pageModel.OnGetAsync(1, string.Empty, string.Empty);

            // Assert
            actionResult
            .Should()
            .BeOfType <PageResult>();

            pageModel
            .FundingPeriods
            .Count()
            .Should()
            .Be(1);
        }
        public async Task SearchDatasetRelationships_GivenResultsReturnedFromSearch_ReturnsOK()
        {
            // Arrange
            SearchRequestViewModel requestModel = new SearchRequestViewModel();

            SpecificationDatasourceRelationshipSearchResultViewModel results = new SpecificationDatasourceRelationshipSearchResultViewModel();

            IDatasetRelationshipsSearchService searchService = CreateSearchService();

            searchService
            .PerformSearch(Arg.Any <SearchRequestViewModel>())
            .Returns(results);

            DatasetRelationshipsSearchController controller = CreateController(searchService);

            // Act
            IActionResult actionResult = await controller.SearchDatasetRelationships(requestModel);

            // Asserts
            actionResult
            .Should()
            .BeOfType <OkObjectResult>();
        }
        public async Task <IActionResult> OnPostAsync(int?pageNumber)
        {
            await PopulatePeriods();

            SearchRequestViewModel searchRequest = new SearchRequestViewModel()
            {
                PageNumber    = pageNumber,
                SearchTerm    = SearchTerm,
                IncludeFacets = false,
                Filters       = new Dictionary <string, string[]> {
                    { "fundingPeriodId", new[] { FundingPeriodId } }
                }
            };

            SearchResults = await _datasetRelationshipsSearchService.PerformSearch(searchRequest);

            if (SearchResults == null)
            {
                return(new StatusCodeResult(500));
            }

            return(Page());
        }
        public async Task <SpecificationDatasourceRelationshipSearchResultViewModel> PerformSearch(SearchRequestViewModel request)
        {
            SearchFilterRequest requestOptions = new SearchFilterRequest()
            {
                Page          = request.PageNumber.HasValue ? request.PageNumber.Value : 1,
                PageSize      = request.PageSize.HasValue ? request.PageSize.Value : 50,
                SearchTerm    = request.SearchTerm,
                IncludeFacets = false,
                Filters       = request.Filters,
            };

            if (request.PageNumber.HasValue && request.PageNumber.Value > 0)
            {
                requestOptions.Page = request.PageNumber.Value;
            }

            PagedResult <SpecificationDatasourceRelationshipSearchResultItem> pagedResult = await _specsClient.FindSpecificationAndRelationships(requestOptions);

            if (pagedResult == null)
            {
                _logger.Error("Find specification data source relationships HTTP request failed");
            }

            SpecificationDatasourceRelationshipSearchResultViewModel viewModel = new SpecificationDatasourceRelationshipSearchResultViewModel();

            viewModel.TotalResults = pagedResult.TotalItems;
            viewModel.CurrentPage  = pagedResult.PageNumber;

            IList <SpecificationDatasourceRelationshipSearchResultItemViewModel> itemResults = new List <SpecificationDatasourceRelationshipSearchResultItemViewModel>();

            foreach (SpecificationDatasourceRelationshipSearchResultItem item in pagedResult.Items)
            {
                itemResults.Add(new SpecificationDatasourceRelationshipSearchResultItemViewModel
                {
                    SpecificationId   = item.Id,
                    SpecificationName = item.Name,
                    CountPhrase       = BuildCountPhrase(item.RelationshipCount)
                });
            }

            IEnumerable <SpecificationDatasourceRelationshipSearchResultItemViewModel> sortedResults = itemResults.OrderBy(f => f.SpecificationName);

            viewModel.SpecRelationships = sortedResults.ToList();

            if (viewModel.TotalResults == 0)
            {
                viewModel.StartItemNumber = 0;
                viewModel.EndItemNumber   = 0;
            }
            else
            {
                viewModel.StartItemNumber = ((requestOptions.Page - 1) * requestOptions.PageSize) + 1;
                viewModel.EndItemNumber   = viewModel.StartItemNumber + requestOptions.PageSize - 1;
            }

            if (viewModel.EndItemNumber > pagedResult.TotalItems)
            {
                viewModel.EndItemNumber = pagedResult.TotalItems;
            }

            viewModel.PagerState = new PagerState(requestOptions.Page, pagedResult.TotalPages, 4);

            return(viewModel);
        }