public void Search_Expands_search_and_filter_to_azure_query()
{
// Setup
string expectedLatestReportedDate = VirtualDateTime.UtcNow.Date.AddDays(-7).ToString("O");
string expectedFilterQuery = string.Join(
" and ",
"SicSectionIds/any(id: id eq 'G' or id eq 'L' or id eq 'C')",
"(Size eq 1 or Size eq 2 or Size eq 3)",
"ReportedYears/any(ReportedYear: ReportedYear eq '2017')",
$"(LatestReportedDate gt {expectedLatestReportedDate} or ReportedExplanationYears/any(ReportedYear: ReportedYear eq '2017'))");
var testParams = new EmployerSearchParameters {
Keywords = "word1 word2 word3",
FilterEmployerSizes = new[] { 1, 2, 3 },
FilterSicSectionIds = new[] { 'G', 'L', 'C' },
FilterReportedYears = new[] { 2017 },
FilterReportingStatus = new[] { 0, 3 },
SearchType = SearchType.ByEmployerName
};
// Test
string resultFilterQuery = testParams.ToFilterQuery();
Assert.AreEqual(expectedFilterQuery, resultFilterQuery);
}
public async Task <SearchViewModel> SearchAsync(EmployerSearchParameters searchParams, string orderBy)
{
bool orderByRelevance = orderBy == "relevance";
var facets = new Dictionary <string, Dictionary <object, long> >();
facets.Add("Size", null);
facets.Add("SicSectionIds", null);
facets.Add("ReportedYears", null);
facets.Add("ReportedLateYears", null);
facets.Add("ReportedExplanationYears", null);
// build the result view model
return(new SearchViewModel {
SizeOptions = GetOrgSizeOptions(searchParams.FilterEmployerSizes, facets["Size"]),
SectorOptions = await GetSectorOptionsAsync(searchParams.FilterSicSectionIds, facets["SicSectionIds"]),
ReportingYearOptions = GetReportingYearOptions(searchParams.FilterReportedYears),
ReportingStatusOptions = GetReportingStatusOptions(searchParams.FilterReportingStatus),
Employers = viewingSearchService.Search(searchParams, orderByRelevance),
search = searchParams.Keywords,
p = searchParams.Page,
s = searchParams.FilterSicSectionIds,
es = searchParams.FilterEmployerSizes,
y = searchParams.FilterReportedYears,
st = searchParams.FilterReportingStatus,
t = searchParams.SearchType.ToInt32().ToString(),
OrderBy = orderBy
});
}
public IEnumerable <DomainEmployer> Search(EmployerSearchParameters searchParameters)
{
var sql = "SELECT * FROM dbo.Employer WHERE ";
var and = "";
if (!string.IsNullOrEmpty(searchParameters.Id))
{
sql += "EmployerId = @Id ";
and = "AND ";
}
if (!string.IsNullOrEmpty(searchParameters.EdsUrn))
{
sql += and + "EDSURN = @EdsUrn ";
and = "AND ";
}
if (!string.IsNullOrEmpty(searchParameters.Name))
{
sql += and + "(FullName LIKE '%' + @Name + '%' OR TradingName LIKE '%' + @Name + '%') ";
and = "AND ";
}
if (!string.IsNullOrEmpty(searchParameters.Location))
{
sql += and + "(Town LIKE '%' + @Location + '%' OR PostCode LIKE '%' + @Location + '%') ";
}
sql += "ORDER BY FullName";
var employers = _getOpenConnection.Query <Employer>(sql, searchParameters).ToList();
return(MapEmployers(employers));
}
[TestCase("uk", "uk")] // Do NOT replace (user might to search by 'uk')
public void EmployerSearchParameters_RemoveTheMostCommonTermsOnOurDatabaseFromTheKeywords(string keywordsToClean,
string expectedOutcome)
{
// Arrange
var employerSearchParameters = new EmployerSearchParameters {
Keywords = keywordsToClean
};
// Act
string actualOutcome = employerSearchParameters.RemoveTheMostCommonTermsOnOurDatabaseFromTheKeywords();
// Assert
Assert.AreEqual(expectedOutcome, actualOutcome);
}
private async Task <PagedResult <EmployerSearchModel> > DoSearchAsync(EmployerSearchParameters searchParams,
Dictionary <string, Dictionary <object, long> > facets)
{
return(await _viewingService.SearchBusinessLogic.EmployerSearchRepository.SearchAsync(
searchParams.Keywords, // .ToSearchQuery(),
searchParams.Page,
searchParams.SearchType,
searchParams.PageSize,
filter : searchParams.ToFilterQuery(),
facets : facets,
orderBy : string.IsNullOrWhiteSpace(searchParams.Keywords)?nameof(EmployerSearchModel.Name) : null,
searchFields : searchParams.SearchFields,
searchMode : searchParams.SearchMode));
}
public EmployerSearchViewModel SearchEmployers(EmployerSearchViewModel searchViewModel)
{
var searchParameters = new EmployerSearchParameters
{
Id = searchViewModel.Id,
EdsUrn = searchViewModel.EdsUrn,
Name = searchViewModel.Name,
Location = searchViewModel.Location
};
var results = _employerService.SearchEmployers(searchParameters);
var employers = results.Select(e => e.Convert()).ToList();
searchViewModel.Employers.Page = employers;
searchViewModel.Employers.ResultsCount = employers.Count;
return(searchViewModel);
}
private List <SearchCachedOrganisation> FilterByOrganisations(List <SearchCachedOrganisation> organisations,
EmployerSearchParameters searchParams)
{
IEnumerable <OrganisationSizes> selectedOrganisationSizes = searchParams.FilterEmployerSizes.Select(s => (OrganisationSizes)s);
IEnumerable <char> selectedSicSections = searchParams.FilterSicSectionIds;
List <int> selectedReportingYears = searchParams.FilterReportedYears.ToList();
IEnumerable <SearchReportingStatusFilter> selectedReportingStatuses =
searchParams.FilterReportingStatus.Select(s => (SearchReportingStatusFilter)s);
IEnumerable <SearchCachedOrganisation> filteredOrgs = organisations.AsEnumerable();
if (selectedOrganisationSizes.Any())
{
filteredOrgs = filteredOrgs.Where(o => o.GetOrganisationSizes(selectedReportingYears).Intersect(selectedOrganisationSizes).Any());
}
if (selectedSicSections.Any())
{
filteredOrgs = filteredOrgs.Where(o => o.SicSectionIds.Intersect(selectedSicSections).Any());
}
if (selectedReportingYears.Any())
{
filteredOrgs = filteredOrgs.Where(o => o.ReportingYears.Intersect(selectedReportingYears).Any());
}
if (selectedReportingStatuses.Any())
{
var reportingStatusFilteredOrgs = new List <SearchCachedOrganisation>();
foreach (SearchReportingStatusFilter status in selectedReportingStatuses)
{
reportingStatusFilteredOrgs = reportingStatusFilteredOrgs.Union(ApplyReportingStatusesFilter(filteredOrgs, status, selectedReportingYears)).ToList();
}
filteredOrgs = reportingStatusFilteredOrgs;
}
return(filteredOrgs.ToList());
}
public IEnumerable <Employer> Search(EmployerSearchParameters searchParameters)
{
throw new NotImplementedException();
}
public PagedResult <EmployerSearchModel> Search(EmployerSearchParameters searchParams, bool orderByRelevance)
{
List <SearchCachedOrganisation> allOrganisations = SearchRepository.CachedOrganisations
.Where(o => o.IncludeInViewingService)
.ToList();
List <SearchCachedOrganisation> filteredOrganisations = FilterByOrganisations(allOrganisations, searchParams);
if (searchParams.Keywords == null)
{
List <SearchCachedOrganisation> orderedOrganisations =
filteredOrganisations.OrderBy(o => o.OrganisationName.OriginalValue).ToList();
List <SearchCachedOrganisation> paginatedResultsForAllOrganisations = PaginateResults(
orderedOrganisations,
searchParams.Page,
searchParams.PageSize);
return(new PagedResult <EmployerSearchModel>
{
Results = ConvertToEmployerSearchModels(paginatedResultsForAllOrganisations),
CurrentPage = searchParams.Page,
PageSize = searchParams.PageSize,
ActualRecordTotal = orderedOrganisations.Count,
VirtualRecordTotal = orderedOrganisations.Count
});
}
string query = searchParams.Keywords.Trim().ToLower();
bool queryContainsPunctuation = WordSplittingRegex.ContainsPunctuationCharacters(query);
List <string> searchTerms = SearchHelper.ExtractSearchTermsFromQuery(query, queryContainsPunctuation);
var matchingOrganisations = new List <SearchCachedOrganisation>();
var convertedResults = new List <EmployerSearchModel>();
if (searchParams.SearchType == SearchType.NotSet)
{
throw new NotImplementedException();
}
if (searchParams.SearchType == SearchType.ByEmployerName)
{
matchingOrganisations = GetMatchingOrganisationsByName(
filteredOrganisations,
searchTerms,
query,
queryContainsPunctuation);
List <RankedViewingSearchOrganisation> organisationsWithRankings = CalculateOrganisationRankings(
matchingOrganisations,
searchTerms,
query,
queryContainsPunctuation);
List <RankedViewingSearchOrganisation> rankedOrganisations = orderByRelevance
? OrderOrganisationsByRank(organisationsWithRankings)
: OrderOrganisationsAlphabetically(organisationsWithRankings);
List <RankedViewingSearchOrganisation> paginatedResults = PaginateResults(
rankedOrganisations,
searchParams.Page,
searchParams.PageSize);
convertedResults = ConvertRankedOrgsToEmployerSearchModels(paginatedResults);
}
if (searchParams.SearchType == SearchType.BySectorType)
{
matchingOrganisations = GetMatchingOrganisationsBySicCode(
filteredOrganisations,
searchTerms,
query,
queryContainsPunctuation);
// Only alphabetically for SIC code search
List <SearchCachedOrganisation> orderedOrganisations =
matchingOrganisations.OrderBy(o => o.OrganisationName.OriginalValue).ToList();
List <SearchCachedOrganisation> paginatedSicCodeResults = PaginateResults(
orderedOrganisations,
searchParams.Page,
searchParams.PageSize);
convertedResults = ConvertSearchCachedOrganisationsToEmployerSearchModels(paginatedSicCodeResults);
}
var pagedResult = new PagedResult <EmployerSearchModel>
{
Results = convertedResults,
CurrentPage = searchParams.Page,
PageSize = searchParams.PageSize,
ActualRecordTotal = matchingOrganisations.Count,
VirtualRecordTotal = matchingOrganisations.Count
};
return(pagedResult);
}
public IEnumerable <Employer> SearchEmployers(EmployerSearchParameters searchParameters)
{
return(_employerReadRepository.Search(searchParameters));
}
public IEnumerable <Employer> SearchEmployers(EmployerSearchParameters searchParameters)
{
return(_searchEmployersStrategy.SearchEmployers(searchParameters));
}
public async Task <SearchViewModel> SearchAsync(EmployerSearchParameters searchParams)
{
var searchResults = new PagedResult <EmployerSearchModel>();
var facets = new Dictionary <string, Dictionary <object, long> >();
facets.Add("Size", null);
facets.Add("SicSectionIds", null);
facets.Add("ReportedYears", null);
facets.Add("ReportedLateYears", null);
facets.Add("ReportedExplanationYears", null);
var searchTermEnteredOnScreen = searchParams.Keywords;
if (searchParams.SearchType == SearchTypes.BySectorType)
{
var list =
await GetListOfSicCodeSuggestionsFromIndexAsync(searchParams.Keywords);
searchParams.FilterCodeIds = list.Select(x => int.Parse(x.Value.SicCodeId));
#region Log the search
if (!string.IsNullOrEmpty(searchParams.Keywords))
{
var detailedListOfReturnedSearchTerms =
string.Join(", ", list.Take(5).Select(x => x.Value.ToLogFriendlyString()));
var telemetryProperties = new Dictionary <string, string>
{
{ "TimeStamp", VirtualDateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.fff") },
{ "QueryTerms", searchParams.Keywords },
{ "ResultCount", list.Count().ToString() },
{ "SearchType", searchParams.SearchType.ToString() },
{ "SampleOfResultsReturned", detailedListOfReturnedSearchTerms }
};
//SharedBusinessLogic.SharedOptions.AppInsightsClient?.TrackEvent("Gpg_SicCode_Suggest", telemetryProperties);
await _viewingService.SearchBusinessLogic.SearchLog.WriteAsync(telemetryProperties);
}
#endregion
searchParams.SearchFields =
$"{nameof(EmployerSearchModel.SicCodeIds)};{nameof(EmployerSearchModel.SicCodeListOfSynonyms)}";
searchParams.Keywords = "*"; // searchTermModified
if (list.Any())
{
searchResults = await DoSearchAsync(searchParams, facets);
}
}
if (searchParams.SearchType == SearchTypes.ByEmployerName)
{
searchParams.Keywords = searchParams.Keywords?.Trim();
searchParams.Keywords = searchParams.RemoveTheMostCommonTermsOnOurDatabaseFromTheKeywords();
searchResults = await DoSearchAsync(searchParams, facets);
}
// build the result view model
return(new SearchViewModel
{
SizeOptions = GetOrgSizeOptions(searchParams.FilterEmployerSizes, facets["Size"]),
SectorOptions = await GetSectorOptionsAsync(searchParams.FilterSicSectionIds, facets["SicSectionIds"]),
ReportingYearOptions = GetReportingYearOptions(searchParams.FilterReportedYears),
ReportingStatusOptions = GetReportingStatusOptions(searchParams.FilterReportingStatus),
Employers = searchResults,
search = searchTermEnteredOnScreen,
p = searchParams.Page,
s = searchParams.FilterSicSectionIds,
es = searchParams.FilterEmployerSizes,
y = searchParams.FilterReportedYears,
st = searchParams.FilterReportingStatus,
t = searchParams.SearchType.ToInt32().ToString()
});
}
