public async Task <IActionResult> SearchPublishedProviders(SearchModel searchModel)
{
if (searchModel == null || searchModel.PageNumber < 1 || searchModel.Top < 1)
{
_logger.Error("A null or invalid search model was provided for searching published providers");
return(new BadRequestObjectResult("An invalid search model was provided"));
}
try
{
if (searchModel.OrderBy.IsNullOrEmpty())
{
searchModel.OrderBy = new[] { "providerName" };
}
IEnumerable <Task <SearchResults <PublishedProviderIndex> > > searchTasks = await BuildSearchTasks(searchModel, Facets);
if (searchTasks.IsNullOrEmpty())
{
return(new InternalServerErrorResult("Failed to build search tasks"));
}
PublishedSearchResults results = new PublishedSearchResults();
await TaskHelper.WhenAllAndThrow(searchTasks.ToArraySafe());
foreach (var searchTask in searchTasks)
{
SearchResults <PublishedProviderIndex> searchResult = searchTask.Result;
if (!searchResult.Facets.IsNullOrEmpty())
{
results.Facets = results.Facets.Concat(searchResult.Facets);
}
else
{
results.TotalCount = (int)(searchResult?.TotalCount ?? 0);
results.Results = searchResult?.Results?.Select(m => new PublishedSearchResult
{
Id = m.Result.Id,
ProviderType = m.Result.ProviderType,
ProviderSubType = m.Result.ProviderSubType,
LocalAuthority = m.Result.LocalAuthority,
FundingStatus = m.Result.FundingStatus,
ProviderName = m.Result.ProviderName,
UKPRN = m.Result.UKPRN,
UPIN = m.Result.UPIN,
URN = m.Result.URN,
FundingValue = m.Result.FundingValue,
SpecificationId = m.Result.SpecificationId,
FundingStreamId = m.Result.FundingStreamId,
FundingPeriodId = m.Result.FundingPeriodId,
HasErrors = m.Result.HasErrors,
Errors = m.Result.Errors
});
}
}
return(new OkObjectResult(results));
}
catch (FailedToQuerySearchException exception)
{
_logger.Error(exception, $"Failed to query search with term: {searchModel.SearchTerm}");
return(new InternalServerErrorResult($"Failed to query search, with exception: {exception.Message}"));
}
}
public async Task DelegatesToSearchRepositoryAndMapsResultsIntoOkObjectResult()
{
Dictionary <string, string[]> nonFacetFilters = new Dictionary <string, string[]>
{
{ "filter1", new[] { "filter1value1", "filter1value2" } }
};
Dictionary <string, string[]> facetFilters = new Dictionary <string, string[]>
{
{ "hasErrors", new[] { "true" } },
{ "providerType", new[] { "test", "" } }
};
SearchModel searchModel = NewSearchModel(builder =>
{
builder.WithTop(50)
.WithPageNumber(1)
.WithSearchTerm(NewRandomString())
.WithIncludeFacets(true);
foreach (var nonFacetFilter in nonFacetFilters)
{
builder.AddFilter(nonFacetFilter.Key, nonFacetFilter.Value);
}
foreach (var facetFilter in facetFilters)
{
builder.AddFilter(facetFilter.Key, facetFilter.Value);
}
});
GivenTheSearchModel(searchModel);
SearchResults <PublishedProviderIndex> searchIndexResults = NewSearchResults(_ =>
_.WithResults(NewPublishedProviderIndex(),
NewPublishedProviderIndex(),
NewPublishedProviderIndex()));
AndTheSearchResults(searchModel, searchIndexResults);
OkObjectResult result = await WhenTheSearchIsMade() as OkObjectResult;
result
.Should()
.NotBeNull();
PublishedSearchResults publishedSearchResults = result.Value as PublishedSearchResults;
publishedSearchResults
.Facets
.Should()
.NotBeNull();
IEnumerable <PublishedSearchResult> results = publishedSearchResults.Results;
results
.Should()
.NotBeNull();
results.Select(_ => _.Id)
.Should()
.BeEquivalentTo(searchIndexResults.Results.Select(_ => _.Result.Id));
await ThenTheFiltersWasSearched(searchModel,
PublishedSearchService.Facets.Length - nonFacetFilters.Count,
"(providerType eq 'test' or providerType eq '') and (hasErrors eq true) and (filter1 eq 'filter1value1' or filter1 eq 'filter1value2')");
await ThenTheFiltersWasSearched(searchModel,
1,
"(providerType eq 'test' or providerType eq '') and (filter1 eq 'filter1value1' or filter1 eq 'filter1value2')");
await AndTheFilterWasSearched(searchModel,
1,
"(hasErrors eq true) and (filter1 eq 'filter1value1' or filter1 eq 'filter1value2')");
}
