protected void TestCanContinueSearchForDynamicDocuments()
{
SearchIndexClient client = GetClient();
IEnumerable <string> hotelIds = Data.IndexDocuments(client, 2001);
var searchParameters =
new SearchParameters()
{
Top = 3000,
OrderBy = new[] { "hotelId asc" },
Select = new[] { "hotelId" }
};
IEnumerable <string> expectedIds =
Data.TestDocuments.Select(d => d.HotelId).Concat(hotelIds).OrderBy(id => id);
DocumentSearchResult <Document> response = client.Documents.Search("*", searchParameters);
AssertKeySequenceEqual(response, expectedIds.Take(1000).ToArray());
Assert.NotNull(response.ContinuationToken);
// Test that ContinueSearch still works even if you toggle GET/POST.
client.UseHttpGetForQueries = !client.UseHttpGetForQueries;
response = client.Documents.ContinueSearch(response.ContinuationToken);
AssertKeySequenceEqual(response, expectedIds.Skip(1000).Take(1000).ToArray());
Assert.NotNull(response.ContinuationToken);
// Toggle GET/POST again.
client.UseHttpGetForQueries = !client.UseHttpGetForQueries;
response = client.Documents.ContinueSearch(response.ContinuationToken);
AssertKeySequenceEqual(response, expectedIds.Last());
Assert.Null(response.ContinuationToken);
}
private JobSearchResults SearchJobs(JobCriteria searchParms)
{
var credential = new SearchCredentials(AZURE_SEARCH_KEY);
SearchServiceClient serviceClient = new SearchServiceClient(ACURE_SEARCH_SERVICE_NAME, credential);
var indexClient = serviceClient.Indexes.GetClient("denvertechjobs");
var sp = new SearchParameters
{
ScoringProfile = (searchParms.Latituede != 0 && searchParms.Latituede != 0) ? "geo" : "newAndHighlyRated",
IncludeTotalResultCount = true,
SearchMode = SearchMode.All,
//Filter = "trioType eq 'Food'"
};
if (searchParms.Latituede != 0 && searchParms.Latituede != 0)
{
var scoreParam = new ScoringParameter("currentLocation", Microsoft.Spatial.GeographyPoint.Create((double)searchParms.Latituede, (double)searchParms.Longitude));
sp.ScoringParameters = new List <ScoringParameter> {
scoreParam
};
}
var searchText = string.Join('|', searchParms.KeyPhrases) + "+" + string.Join('|', searchParms.Skills) + "+" + searchParms.Profession;
DocumentSearchResult <JobDocument> response = indexClient.Documents.Search <JobDocument>(searchText, sp);
var results = new JobSearchResults {
TotalResults = response.Count
};
if (response.Results.Any())
{
var docs = (from d in response.Results select d.Document).ToList();
results.ResultItems.AddRange(docs);
}
return(results);
}
private async Task SendResults(IDialogContext context, DocumentSearchResult results)
{
var message = context.MakeMessage();
if (results.Results.Count == 0)
{
await context.PostAsync("There were no results found for \"" + searchText + "\".");
context.Done <object>(null);
}
else
{
SearchHitStyler searchHitStyler = new SearchHitStyler();
searchHitStyler.Apply(
ref message,
"Here are the results that I found:",
results.Results.Select(r => ImageMapper.ToSearchHit(r)).ToList().AsReadOnly());
await context.PostAsync(message);
context.Done <object>(null);
}
}
protected void TestCanSearchWithSelectedFields()
{
SearchIndexClient client = GetClientForQuery();
var searchParameters =
new SearchParameters()
{
SearchFields = new[] { "category", "hotelName" },
Select = new[] { "hotelName", "baseRate" }
};
DocumentSearchResult <Hotel> response =
client.Documents.Search <Hotel>("fancy luxury", searchParameters);
var expectedDoc = new Hotel()
{
HotelName = "Fancy Stay", BaseRate = 199.0
};
Assert.NotNull(response.Results);
Assert.Equal(1, response.Results.Count);
Assert.Equal(expectedDoc, response.Results.First().Document);
}
protected void TestCanSearchWithLuceneSyntax()
{
SearchIndexClient client = GetClientForQuery();
var searchParameters =
new SearchParameters()
{
QueryType = QueryType.Full,
Select = new[] { "hotelName", "baseRate" }
};
DocumentSearchResult <Hotel> response =
client.Documents.Search <Hotel>("hotelName:roch~", searchParameters);
var expectedDoc = new Hotel()
{
HotelName = "Roach Motel", BaseRate = 79.99
};
Assert.NotNull(response.Results);
Assert.Equal(1, response.Results.Count);
Assert.Equal(expectedDoc, response.Results.First().Document);
}
protected void TestCanSearchWithRegex()
{
SearchIndexClient client = GetClientForQuery();
var searchParameters =
new SearchParameters()
{
QueryType = QueryType.Full,
Select = new[] { "hotelName", "rating" }
};
DocumentSearchResult <Hotel> response =
client.Documents.Search <Hotel>(@"hotelName:/.*oach.*\/?/", searchParameters);
var expectedDoc = new Hotel()
{
HotelName = "Roach Motel", Rating = 1
};
Assert.NotNull(response.Results);
Assert.Equal(1, response.Results.Count);
Assert.Equal(expectedDoc, response.Results.First().Document);
}
public async Task <DocumentSearchResult> Search(string searchText, string filterText)
{
if (string.IsNullOrWhiteSpace(searchText))
{
searchText = "*";
}
SearchParameters searchParams = null;
if (!string.IsNullOrWhiteSpace(filterText))
{
searchParams = new SearchParameters()
{
Filter = filterText
}
}
;
DocumentSearchResult documentSearchResult = await this.SearchIndexClient.Documents.SearchAsync(searchText, searchParams);
return(documentSearchResult);
}
}
public static async Task <List <SuggestionResponse> > GetSuggestions(string azureSearchTerm)
{
SearchParameters searchParameters = new SearchParameters
{
Select = new[]
{
"id", "firstAndLastName"
},
IncludeTotalResultCount = true,
QueryType = QueryType.Simple,
SearchFields = new string[] { "firstAndLastName" },
Top = 5
};
ISearchIndexClient indexClient = AzureSearchConnectionCache.GetIndexClient(AzureSearchConnectionCache.IndexNames.names);
DocumentSearchResult <NameIndexDataStructure> searchResults = await indexClient.Documents.SearchAsync <NameIndexDataStructure>(azureSearchTerm, searchParameters);
List <SearchResult <NameIndexDataStructure> > results = searchResults.Results.ToList();
List <SuggestionResponse> suggestions = new List <SuggestionResponse>();
foreach (NameIndexDataStructure c in results.Select(r => r.Document))
{
suggestions.Add(new SuggestionResponse
{
Category = "Name",
SubCategory = new SubCategory
{
Code = null,
Text = null
},
Suggestion = c.firstAndLastName
});
}
return(suggestions);
}
public static async Task <List <SuggestionResponse> > GetSuggestions(string azureSearchTerm, SearchServiceClient serviceClient)
{
SearchParameters searchParameters = new SearchParameters
{
Select = new[]
{
"id", "isPrimaryCare", "condition"
},
IncludeTotalResultCount = true,
QueryType = QueryType.Simple,
SearchFields = new string[] { "condition" },
Top = 6
};
ISearchIndexClient indexClient = serviceClient.Indexes.GetClient("conditions");
DocumentSearchResult <ConditionIndexDataStructure> searchResults = await indexClient.Documents.SearchAsync <ConditionIndexDataStructure>(azureSearchTerm, searchParameters);
List <SearchResult <ConditionIndexDataStructure> > results = searchResults.Results.ToList();
List <SuggestionResponse> suggestions = new List <SuggestionResponse>();
foreach (ConditionIndexDataStructure c in results.Select(r => r.Document))
{
suggestions.Add(new SuggestionResponse
{
Category = "Condition",
SubCategory = new SubCategory
{
Code = (c.isPrimaryCare ? "PrimaryCare" : "Specialist"),
Text = (c.isPrimaryCare ? "Primary Care Providers" : "Specialists")
},
Suggestion = c.condition
});
}
return(suggestions);
}
/// <summary>
/// Inserts a single venue document into the collection
/// </summary>
/// <param name="venue">The Venue to insert</param>
/// <param name="log">ILogger for logging info/errors</param>
public async Task <ResourceResponse <Document> > InsertDocAsync(Venue venue, ILogger log)
{
// Add venue doc to collection
try {
if (venue.id == Guid.Empty)
{
venue.id = Guid.NewGuid();
}
Uri uri = UriFactory.CreateDocumentCollectionUri(SettingsHelper.Database, SettingsHelper.Collection);
// Insert venue doc, get it's cosmos "sequence" value, then write it back into LocationId property
Document doc = await docClient.CreateDocumentAsync(uri, venue);
Sequence sequence = docClient.CreateDocumentQuery <Sequence>(uri, $"SELECT DOCUMENTID(v) AS SequenceId FROM v " +
$"WHERE v.id = \"{venue.id}\"")
.ToList()
.First();
doc.SetPropertyValue("LocationId", sequence.SequenceId + LOCATIONID_OFFSET);
// Add latitude & logitude from onspd azure search
log.LogInformation($"{count++}: getting lat/long for location {venue.POSTCODE}");
SearchParameters parameters = new SearchParameters
{
Select = new[] { "pcds", "lat", "long" },
SearchMode = SearchMode.All,
Top = 1,
QueryType = QueryType.Full
};
DocumentSearchResult <dynamic> results = _onspdIndex.Documents.Search <dynamic>(venue.POSTCODE, parameters);
doc.SetPropertyValue("Latitude", (decimal?)results?.Results?.FirstOrDefault()?.Document?.lat);
doc.SetPropertyValue("Longitude", (decimal?)results?.Results?.FirstOrDefault()?.Document?.@long);
return(await docClient.UpsertDocumentAsync(uri, doc));
} catch (Exception ex) {
throw ex;
}
}
public void SearchDocuments(ISearchIndexClient indexClient, string searchText, string filter = null,
List <string> facet = null)
{
var sp = new SearchParameters();
if (!string.IsNullOrEmpty(filter))
{
sp.Filter = filter;
}
if (facet != null)
{
sp.Facets = facet;
}
DocumentSearchResult <Contact> response = indexClient.Documents.Search <Contact>(searchText, sp);
if (response.Facets != null)
{
FacetResults facetResults = response.Facets;
foreach (var facetResult in facetResults)
{
Console.WriteLine($"Facet Key : {facetResult.Key}");
foreach (var f in facetResult.Value)
{
Console.WriteLine($"f.value, ({f.Count})");
}
}
}
else
{
foreach (SearchResult <Contact> result in response.Results)
{
Console.WriteLine(result.Document);
}
}
}
public static async Task <List <SuggestionResponse> > GetSuggestions(string azureSearchTerm, SearchServiceClient serviceClient)
{
SearchParameters searchParameters = new SearchParameters
{
Select = new[]
{
"id", "insurance"
},
IncludeTotalResultCount = true,
QueryType = QueryType.Simple,
SearchFields = new string[] { "insurance" },
Top = 5
};
ISearchIndexClient indexClient = serviceClient.Indexes.GetClient("insurances");
DocumentSearchResult <InsuranceIndexDataStructure> searchResults = await indexClient.Documents.SearchAsync <InsuranceIndexDataStructure>(azureSearchTerm, searchParameters);
List <SearchResult <InsuranceIndexDataStructure> > results = searchResults.Results.ToList();
List <SuggestionResponse> suggestions = new List <SuggestionResponse>();
foreach (InsuranceIndexDataStructure c in results.Select(r => r.Document))
{
suggestions.Add(new SuggestionResponse
{
Category = "Insurance",
SubCategory = new SubCategory
{
Code = null,
Text = null
},
Suggestion = c.insurance
});
}
return(suggestions);
}
public async Task <ActionResult> Facets()
{
InitSearch();
// Set up the facets call in the search parameters.
SearchParameters sp = new SearchParameters()
{
// Search all Tags, but limit the total number to 100, and add up to 20 categories.
// Field names specified here must be marked as "IsFacetable" in the model, or the search call will throw an exception.
Facets = new List <string> {
"Tags,count:100", "Category,count:20"
},
};
DocumentSearchResult <Hotel> searchResult = await _indexClient.Documents.SearchAsync <Hotel>("*", sp);
// Convert the results to two lists that can be displayed in the client.
List <string> facets = searchResult.Facets["Tags"].Select(x => x.Value.ToString()).ToList();
List <string> categories = searchResult.Facets["Category"].Select(x => x.Value.ToString()).ToList();
// Combine and return the lists.
facets.AddRange(categories);
return(new JsonResult(facets));
}
private static async Task <List <ImageInformation> > SearchImagesAsync(string searchQuery)
{
List <ImageInformation> images = new List <ImageInformation>();
SearchServiceClient serviceClient = new SearchServiceClient("[YOUR AZURE SEARCH SERVICE NAME]", new SearchCredentials("[YOUR AZURE SEARCH API KEY]"));
var sp = new SearchParameters()
{
Top = 10
};
ISearchIndexClient indexClient = serviceClient.Indexes.GetClient("tags");
DocumentSearchResult response = await indexClient.Documents.SearchAsync(searchQuery.Trim() + "*", sp);
images = (from result in response.Results
select new ImageInformation()
{
Id = new Guid((string)result.Document["id"]),
Caption = (result.Document["caption"] + "").ToFirstCharUpper(),
Tags = ((string[])result.Document["tags"]).ToList()
}).ToList();
return(images);
}
public async Task <DocumentSearchResult> Search([FromUri] string searchText)
{
var credentials = new SearchCredentials(AzureSearchConfig.SearchServiceApiKey);
SearchIndexClient client = new SearchIndexClient(AzureSearchConfig.SearchServiceName
, AzureSearchConfig.SearchIndexName, credentials);
var callersGeoLocation = LocationHelper.GetCallerLocation();
var scoringParam = new ScoringParameter(
AzureSearchConfig.GeoScoringParameterName,
new string[] { callersGeoLocation.Longitude.ToString(), callersGeoLocation.Latitude.ToString() });
var parameters = new SearchParameters
{
SearchMode = SearchMode.All,
Facets = AzureSearchConfig.SearchIndexFacets,
ScoringProfile = AzureSearchConfig.ScoringProfileName,
ScoringParameters = new[] { scoringParam }
};
DocumentSearchResult searchResult = await client.Documents.SearchAsync(searchText, parameters);
return(searchResult);
}
protected void TestCanSearchWithSynonyms()
{
SearchServiceClient searchClient = Data.GetSearchServiceClient();
const string synonymMapName = "names";
SynonymMap synonymMap = new SynonymMap(name: synonymMapName, format: SynonymMapFormat.Solr, synonyms: "luxury,fancy");
searchClient.SynonymMaps.Create(synonymMap);
SearchIndexClient client = GetClientForQuery();
Index index = searchClient.Indexes.Get(client.IndexName);
index.Fields.First(f => f.Name == "hotelName").SynonymMaps = new[] { synonymMapName };
searchClient.Indexes.CreateOrUpdate(index);
var searchParameters =
new SearchParameters()
{
QueryType = QueryType.Full,
SearchFields = new[] { "hotelName" },
Select = new[] { "hotelName", "baseRate" }
};
DocumentSearchResult <Hotel> response =
client.Documents.Search <Hotel>("luxury", searchParameters);
var expectedDoc = new Hotel()
{
HotelName = "Fancy Stay", BaseRate = 199
};
Assert.NotNull(response.Results);
Assert.Equal(1, response.Results.Count);
Assert.Equal(expectedDoc, response.Results.First().Document);
}
public ActionResult SearchInBlob(string searchString)
{
Task <SearchIndexClient> callTask = Task.Run(() => CreateSearchIndexClientAsync("docs-blob-index"));
callTask.Wait();
var searchClient = callTask.Result;
SearchParameters parameters = new SearchParameters()
{
Select = new[] { "metadata_storage_name" }
};
DocumentSearchResult results = searchClient.Documents.Search(searchString, parameters);
String result = String.Empty;
if (results.Results.Count > 0)
{
result = results.Results.Select(r => r.Document.FirstOrDefault())
.Select(d => $"<li>File name: {d.Value}</li>")
.Aggregate((current, next) => current + "\n" + next);
return(Content($"<ul>{result}</ul>"));
}
return(Content("Data not found."));
}
public dynamic GetQualificationById(string LARSRef)
{
try {
//_log.LogInformation($"Searching by {LARSRef}");
SearchParameters parms = new SearchParameters()
{
Top = 10
};
DocumentSearchResult <dynamic> results =
_index.Documents.Search <dynamic>(LARSRef, parms);
//_log.LogInformation($"{results.Count ?? 0} matches found");
if (results.Results.Count > 0)
{
return(results.Results[0].Document);
}
else
{
return(null);
}
} catch (Exception ex) {
//_log.LogError(ex, "Error in GetQualificationById", LARSRef);
throw ex;
}
}
public async static Task <List <SearchResultInformation> > SearchAsync(string searchQuery)
{
List <SearchResultInformation> searchResults = new List <SearchResultInformation>();
SearchServiceClient serviceClient = new SearchServiceClient("tagur", new SearchCredentials(SearchConstants.SearchApiKey));
var sp = new SearchParameters();
ISearchIndexClient indexClient = serviceClient.Indexes.GetClient("tags");
DocumentSearchResult response = await indexClient.Documents.SearchAsync(searchQuery, sp);
var results = response.Results;
var next = results.Select(s => s.Document).Where(w => w.ContainsKey("id"));
searchResults = (from result in next
select new SearchResultInformation()
{
Id = new Guid((string)result["id"]),
Caption = ((string)result["caption"] + "").ToFirstCharUpper(),
Tags = ((string[])result["tags"]).ToList(),
}).ToList();
return(searchResults);
}
static int GetCurrentDocCount(ISearchIndexClient IndexClient)
{
// Get the current doc count of the specified index
try
{
SearchParameters sp = new SearchParameters()
{
SearchMode = SearchMode.All,
IncludeTotalResultCount = true
};
IndexClient.LongRunningOperationRetryTimeout = 600;
// search will return lots of data and may not return if "$top=1" is not specified
DocumentSearchResult <Microsoft.Azure.Search.Models.Document> response = IndexClient.Documents.Search("*&$top=1", sp);
return(Convert.ToInt32(response.Count));
}
catch (Exception ex)
{
Console.WriteLine(" Error: {0}", ex.Message.ToString());
}
return(-1);
}
private void TestCanSearchWithCustomConverter <TBook, TAuthor>(Action <SearchIndexClient> customizeSettings = null)
where TBook : CustomBookBase <TAuthor>, new()
where TAuthor : CustomAuthor, new()
{
customizeSettings = customizeSettings ?? (client => { });
SearchServiceClient serviceClient = Data.GetSearchServiceClient();
Index index = Book.DefineIndex();
serviceClient.Indexes.Create(index);
SearchIndexClient indexClient = Data.GetSearchIndexClient(index.Name);
customizeSettings(indexClient);
var doc = new TBook()
{
InternationalStandardBookNumber = "123",
Name = "Lord of the Rings",
AuthorName = new TAuthor()
{
FullName = "J.R.R. Tolkien"
},
PublishDateTime = new DateTime(1954, 7, 29)
};
var batch = IndexBatch.Upload(new[] { doc });
indexClient.Documents.Index(batch);
SearchTestUtilities.WaitForIndexing();
DocumentSearchResult <TBook> response = indexClient.Documents.Search <TBook>("*");
Assert.Equal(1, response.Results.Count);
Assert.Equal(doc, response.Results[0].Document);
}
public static async Task <List <SuggestionResponse> > GetSuggestions(string azureSearchTerm)
{
SearchParameters searchParameters = new SearchParameters
{
Select = new[]
{
"id", "specialty", "alias"
},
IncludeTotalResultCount = true,
QueryType = QueryType.Simple,
SearchFields = new string[] { "alias" },
Top = 5
};
ISearchIndexClient indexClient = AzureSearchConnectionCache.GetIndexClient(AzureSearchConnectionCache.IndexNames.specialties);
DocumentSearchResult <SpecialtyIndexDataStructure> searchResults = await indexClient.Documents.SearchAsync <SpecialtyIndexDataStructure>(azureSearchTerm, searchParameters);
List <SearchResult <SpecialtyIndexDataStructure> > results = searchResults.Results.ToList();
List <SuggestionResponse> suggestions = new List <SuggestionResponse>();
foreach (SpecialtyIndexDataStructure s in results.Select(r => r.Document))
{
suggestions.Add(new SuggestionResponse
{
Category = "Specialty",
SubCategory = new SubCategory
{
Code = "",
Text = s.specialty //If we have a specialty without an alias, do we do the right thing here? TODO
},
Suggestion = s.alias
});
}
return(suggestions);
}
protected void TestCanContinueSearchWithoutTop()
{
SearchIndexClient client = GetClient();
IEnumerable <string> hotelIds = IndexDocuments(client, 167);
var searchParameters =
new SearchParameters()
{
OrderBy = new[] { "hotelId asc" },
Select = new[] { "hotelId" }
};
IEnumerable <string> expectedIds =
Data.TestDocuments.Select(d => d.HotelId).Concat(hotelIds).OrderBy(id => id);
DocumentSearchResult <Hotel> response = client.Documents.Search <Hotel>("*", searchParameters);
AssertKeySequenceEqual(response, expectedIds.Take(50).ToArray());
Assert.NotNull(response.ContinuationToken);
response = client.Documents.ContinueSearch <Hotel>(response.ContinuationToken);
AssertKeySequenceEqual(response, expectedIds.Skip(50).Take(50).ToArray());
Assert.NotNull(response.ContinuationToken);
response = client.Documents.ContinueSearch <Hotel>(response.ContinuationToken);
AssertKeySequenceEqual(response, expectedIds.Skip(100).Take(50).ToArray());
Assert.NotNull(response.ContinuationToken);
response = client.Documents.ContinueSearch <Hotel>(response.ContinuationToken);
AssertKeySequenceEqual(response, expectedIds.Skip(150).ToArray());
Assert.Null(response.ContinuationToken);
}
private SearchResults <TDocument> ExecuteGetResults <TDocument>(AzureQuery query, AzureSearchResults <TDocument> processedResults, DocumentSearchResult results)
{
var searchHits = processedResults.GetSearchHits();
Sitecore.ContentSearch.Linq.FacetResults facets = null;
if (query.FacetQueries != null && query.FacetQueries.Count > 0)
{
facets = ExecuteGetFacets(query);
}
return(new SearchResults <TDocument>(searchHits, (int)results.Count, facets));
}
private TResult ApplyScalarMethods <TResult, TDocument>(AzureQuery query, AzureSearchResults <TDocument> processedResults, DocumentSearchResult results)
{
var queryMethod = query.Methods.FirstOrDefault();
object obj;
switch (queryMethod.MethodType)
{
case QueryMethodType.All:
obj = true;
//Check for CustomMethod
var customMethod = queryMethod as CustomMethod;
if (customMethod != null)
{
switch (customMethod.CustomMethodType)
{
case Linq.Nodes.CustomQueryMethodTypes.GetHightlights:
obj = ExecuteGetHighlightResults(query);
break;
}
}
break;
case QueryMethodType.Any:
obj = (processedResults.Any() ? 1 : 0);
break;
case QueryMethodType.Count:
obj = query.Methods.Any(m =>
{
if (m.MethodType != QueryMethodType.Skip)
{
return(m.MethodType == QueryMethodType.Take);
}
return(true);
}) ? processedResults.Count() : results.Count;
break;
case QueryMethodType.ElementAt:
obj = !((ElementAtMethod)queryMethod).AllowDefaultValue ? processedResults.ElementAt(((ElementAtMethod)queryMethod).Index) : processedResults.ElementAtOrDefault(((ElementAtMethod)queryMethod).Index);
break;
case QueryMethodType.First:
obj = !((FirstMethod)queryMethod).AllowDefaultValue ? processedResults.First() : processedResults.FirstOrDefault();
break;
case QueryMethodType.Last:
obj = !((LastMethod)queryMethod).AllowDefaultValue ? processedResults.Last() : processedResults.LastOrDefault();
break;
case QueryMethodType.Single:
obj = !((SingleMethod)queryMethod).AllowDefaultValue ? processedResults.Single() : processedResults.SingleOrDefault();
break;
case QueryMethodType.GetResults:
obj = ExecuteGetResults <TDocument>(query, processedResults, results);
break;
case QueryMethodType.GetFacets:
obj = ExecuteGetFacets(query);
break;
default:
throw new InvalidOperationException("Invalid query method: " + queryMethod.MethodType);
}
return((TResult)Convert.ChangeType(obj, typeof(TResult)));
}
private AzureSearchResults <TElement> ApplySearchMethods <TElement>(AzureQuery query, DocumentSearchResult searchHits)
{
var list = query.Methods != null ? new List <QueryMethod>(query.Methods) : new List <QueryMethod>();
list.Reverse();
SelectMethod selectMethod = null;
foreach (var queryMethod in list)
{
if (queryMethod.MethodType == QueryMethodType.Select)
{
selectMethod = (SelectMethod)queryMethod;
}
}
int startIndex = 0;
int endIndex = searchHits.Results.Count - 1;
return(new AzureSearchResults <TElement>(context, query, searchHits, startIndex, endIndex, selectMethod, query.ExecutionContexts, query.VirtualFieldProcessors, FieldNameTranslator));
}
private static void WriteDocuments(DocumentSearchResult<Hotel> searchResults)
{
foreach (SearchResult<Hotel> result in searchResults.Results)
{
Console.WriteLine(result.Document);
}
Console.WriteLine();
}
private bool Search(string text)
{
bool result = false;
if (_indexClient != null)
{
DocumentSearchResult <Media> response = null;
listSearchResult.Items.Clear();
SearchParameters parameters = new SearchParameters
{
Top = 3
};
try
{
if (string.IsNullOrEmpty(text))
{
text = "*";
}
response = _indexClient.Documents.Search <Media>(text, parameters);
}
catch (Exception e)
{
TextBoxLogWriteLine("Exception while searching media found for : " + textBoxSearch.Text + " exception: " + e.Message);
}
if ((response != null) && (response.Results.Count > 0))
{
TextBoxLogWriteLine("Search result for : " + textBoxSearch.Text);
foreach (SearchResult <Media> res in response.Results)
{
TextBoxLogWriteLine(res.Document.ToString());
int seconds = GetWEBVTTTimeInSeconds(res.Document.subtitleStartTime);
string uri = string.Empty;
string subtitleEncoded = UriEncode(res.Document.subtitleUrl);
string mediaEncoded = UriEncode(res.Document.mediaUrl);
string lang = res.Document.subtitleLanguage.Substring(0, 2);
if (res.Document.isAudio == true)
{
uri = textBoxPlayerUri.Text + "?audiourl=" + mediaEncoded + "&subtitles=" + lang + "," + lang + "," + subtitleEncoded + "&time=" + seconds.ToString();
}
else
{
uri = textBoxPlayerUri.Text + "?url=" + mediaEncoded + "&subtitles=" + lang + "," + lang + "," + subtitleEncoded + "&time=" + seconds.ToString();
}
TextBoxLogWriteLine("Player Uri: " + uri);
string item = ((res.Document.isAudio == true) ? "AUDIO " : "VIDEO ") + res.Document.mediaName + "TIME: " + res.Document.subtitleStartTime + " CONTENT: '" + res.Document.subtitleContent + "' URL: " + uri;
listSearchResult.Items.Add(item);
}
if (listSearchResult.Items.Count > 0)
{
listSearchResult.SelectedIndex = 0;
}
UpdateControls();
result = true;
}
else
{
TextBoxLogWriteLine("No media found for : " + textBoxSearch.Text);
}
}
return(result);
}
protected void TestCanRoundTripNonNullableValueTypes()
{
SearchServiceClient serviceClient = Data.GetSearchServiceClient();
var index = new Index()
{
Name = SearchTestUtilities.GenerateName(),
Fields = FieldBuilder.BuildForType <NonNullableModel>()
};
serviceClient.Indexes.Create(index);
SearchIndexClient indexClient = Data.GetSearchIndexClient(index.Name);
var startDate = new DateTimeOffset(2015, 11, 24, 14, 01, 00, TimeSpan.FromHours(-8));
DateTime endDate = startDate.UtcDateTime + TimeSpan.FromDays(15);
var doc1 = new NonNullableModel()
{
Key = "123",
Count = 3,
EndDate = endDate,
IsEnabled = true,
Rating = 5,
Ratio = 3.14,
StartDate = startDate,
TopLevelBucket = new Bucket()
{
BucketName = "A", Count = 12
},
Buckets = new[]
{
new Bucket()
{
BucketName = "B", Count = 20
},
new Bucket()
{
BucketName = "C", Count = 7
}
}
};
var doc2 = new NonNullableModel()
{
Key = "456",
Count = default(long),
EndDate = default(DateTime),
IsEnabled = default(bool),
Rating = default(int),
Ratio = default(double),
StartDate = default(DateTimeOffset),
TopLevelBucket = default(Bucket),
Buckets = new[] { default(Bucket) }
};
var batch = IndexBatch.Upload(new[] { doc1, doc2 });
indexClient.Documents.Index(batch);
SearchTestUtilities.WaitForIndexing();
DocumentSearchResult <NonNullableModel> response = indexClient.Documents.Search <NonNullableModel>("*");
Assert.Equal(2, response.Results.Count);
Assert.Equal(doc1, response.Results[0].Document);
Assert.Equal(doc2, response.Results[1].Document);
}
protected void TestCanSearchWithValueFacets()
{
SearchIndexClient client = GetClientForQuery();
var searchParameters =
new SearchParameters()
{
Facets = new[]
{
"rating,count:2,sort:-value",
"smokingAllowed,sort:count",
"category",
"lastRenovationDate,interval:year",
"rooms/baseRate,sort:value",
"tags,sort:value"
}
};
DocumentSearchResult <Hotel> response = client.Documents.Search <Hotel>("*", searchParameters);
AssertContainsKeys(response, Data.TestDocuments.Select(d => d.HotelId).ToArray());
Assert.NotNull(response.Facets);
AssertValueFacetsEqual(
GetValueFacetsForField <long>(response.Facets, "rating", 2),
new ValueFacetResult <long>(1, 5),
new ValueFacetResult <long>(4, 4));
AssertValueFacetsEqual(
GetValueFacetsForField <bool>(response.Facets, "smokingAllowed", 2),
new ValueFacetResult <bool>(4, false),
new ValueFacetResult <bool>(3, true));
AssertValueFacetsEqual(
GetValueFacetsForField <string>(response.Facets, "category", 3),
new ValueFacetResult <string>(5, "Budget"),
new ValueFacetResult <string>(1, "Boutique"),
new ValueFacetResult <string>(1, "Luxury"));
AssertValueFacetsEqual(
GetValueFacetsForField <DateTimeOffset>(response.Facets, "lastRenovationDate", 6),
new ValueFacetResult <DateTimeOffset>(1, new DateTimeOffset(1970, 1, 1, 0, 0, 0, TimeSpan.Zero)),
new ValueFacetResult <DateTimeOffset>(1, new DateTimeOffset(1982, 1, 1, 0, 0, 0, TimeSpan.Zero)),
new ValueFacetResult <DateTimeOffset>(2, new DateTimeOffset(1995, 1, 1, 0, 0, 0, TimeSpan.Zero)),
new ValueFacetResult <DateTimeOffset>(1, new DateTimeOffset(1999, 1, 1, 0, 0, 0, TimeSpan.Zero)),
new ValueFacetResult <DateTimeOffset>(1, new DateTimeOffset(2010, 1, 1, 0, 0, 0, TimeSpan.Zero)),
new ValueFacetResult <DateTimeOffset>(1, new DateTimeOffset(2012, 1, 1, 0, 0, 0, TimeSpan.Zero)));
AssertValueFacetsEqual(
GetValueFacetsForField <double>(response.Facets, "rooms/baseRate", 4),
new ValueFacetResult <double>(1, 2.44),
new ValueFacetResult <double>(1, 7.69),
new ValueFacetResult <double>(1, 8.09),
new ValueFacetResult <double>(1, 9.69));
AssertValueFacetsEqual(
GetValueFacetsForField <string>(response.Facets, "tags", 10),
new ValueFacetResult <string>(1, "24-hour front desk service"),
new ValueFacetResult <string>(1, "air conditioning"),
new ValueFacetResult <string>(4, "budget"),
new ValueFacetResult <string>(1, "coffee in lobby"),
new ValueFacetResult <string>(2, "concierge"),
new ValueFacetResult <string>(1, "motel"),
new ValueFacetResult <string>(2, "pool"),
new ValueFacetResult <string>(1, "restaurant"),
new ValueFacetResult <string>(1, "view"),
new ValueFacetResult <string>(4, "wifi"));
}
private async Task MessageReceivedAsync(IDialogContext context, IAwaitable <IMessageActivity> argument)
{
var message = await argument;
var first = false;
context.UserData.TryGetValue <bool> ("FirstTime", out first);
if (first)
{
keywords = message.Text;
context.UserData.SetValue <bool>("FirstTime", false);
await context.PostAsync("What do you want to know about the subject?");
}
else
{
var fullQuestion = message.Text;
AzureSearchService searchService = new AzureSearchService();
try
{
DocumentSearchResult <Models.SearchResult> results = await searchService.SearchAsync(keywords, fullQuestion);
List <Attachment> attachements = new List <Attachment>();
foreach (var res in results.Results)
{
var hero = GetHeroCard(
res.Document.Title,
"",
res.Document.Description,
new CardAction(ActionTypes.OpenUrl, "Learn more", value: res.Document.URL));
attachements.Add(hero);
}
if (attachements.Count > 0)
{
await ShowHeroCard(context, attachements);
}
context.Wait(MessageReceivedAsync);
}
catch (Exception ex)
{
System.Diagnostics.Debug.WriteLine(ex.Message);
}
finally
{
}
}
/*
* // Sample code for carousel
* List<Attachment> attachements = new List<Attachment>();
*
* var hero = GetHeroCard(
* "Azure Storage",
* "Offload the heavy lifting of data center management",
* "Store and help protect your data. Get durable, highly available data storage across the globe and pay only for what you use.",
* new CardImage(url: "https://docs.microsoft.com/en-us/azure/storage/media/storage-introduction/storage-concepts.png"),
* new CardAction(ActionTypes.OpenUrl, "Learn more", value: "https://azure.microsoft.com/en-us/services/storage/"));
* attachements.Add(hero);
*
* await ShowHeroCard(context, attachements);
* context.Wait(MessageReceivedAsync);
*/
}
