private async Task <SearchIndex> CreateDemoIndexAsync(SearchIndexClient indexClient)
{
FieldBuilder builder = new FieldBuilder();
var index = new SearchIndex(_indexName)
{
Fields = builder.Build(typeof(DemoIndex))
};
try
{
indexClient.GetIndex(index.Name);
indexClient.DeleteIndex(index.Name);
}
catch (RequestFailedException ex) when(ex.Status == 404)
{
//if the specified index not exist, 404 will be thrown.
}
try
{
await indexClient.CreateIndexAsync(index);
}
catch (RequestFailedException ex)
{
throw new Exception("Failed to create the index", ex);
}
return(index);
}
private static async Task CreateIndexAsync(string indexName, SearchIndexClient indexClient)
{
// Create a new search index structure that matches the properties of the Book class.
FieldBuilder bulder = new FieldBuilder();
var definition = new SearchIndex(indexName, bulder.Build(typeof(Book)));
await indexClient.CreateIndexAsync(definition);
}
/// <summary>
/// Executes code that runs exactly once at the beginning of test execution.
/// </summary>
/// <returns>Task representing the global setup work.</returns>
public override async Task GlobalSetupAsync()
{
SearchIndex index = new(_indexName)
{
Fields = new FieldBuilder().Build(typeof(Hotel)),
Suggesters = { new SearchSuggester(SuggesterName, new string[] { nameof(Hotel.Description), nameof(Hotel.HotelName) }) }
};
await _searchIndexClient.CreateIndexAsync(index);
}
private static async Task CreateIndexAsync(string indexName, SearchIndexClient indexClient)
{
// Create a new search index structure that matches the properties of the Hotel class.
// The Address class is referenced from the Hotel class. The FieldBuilder
// will enumerate these to create a complex data structure for the index.
FieldBuilder builder = new FieldBuilder();
var definition = new SearchIndex(indexName, builder.Build(typeof(Hotel)));
await indexClient.CreateIndexAsync(definition);
}
public async Task CreateIndex()
{
FieldBuilder bulder = new FieldBuilder();
var definition = new SearchIndex(_index, bulder.Build(typeof(PersonCity)));
definition.Suggesters.Add(new SearchSuggester(
"personSg", new string[] { "Name", "FamilyName", "Info", "CityCountry" }
));
await _searchIndexClient.CreateIndexAsync(definition).ConfigureAwait(false);
}
private static async Task CreateIndex(string searchServiceEndpoint, ILogger log)
{
log.LogInformation("init-accelerator: Creating index " + Constants.indexName);
try
{
var idxclient = new SearchIndexClient(new Uri(searchServiceEndpoint), new AzureKeyCredential(GetAppSetting("SearchServiceApiKey")));
SearchIndex index = new SearchIndex(Constants.indexName)
{
Fields =
{
new SearchField("content", SearchFieldDataType.String)
{
IsSearchable = true, IsSortable = false, IsFilterable = false, IsFacetable = false
},
new SearchField("metadata_storage_path", SearchFieldDataType.String)
{
IsSearchable = true, IsSortable = false, IsFilterable = false, IsFacetable = false
},
new SearchField("id", SearchFieldDataType.String)
{
IsKey = true, IsSearchable = true, IsSortable = false, IsFilterable = false,IsFacetable = false
},
new SearchField("metadata_storage_name", SearchFieldDataType.String)
{
IsSearchable = true, IsSortable = false, IsFilterable = false, IsFacetable = false
},
new SearchField("status", SearchFieldDataType.String)
{
IsSearchable = false, IsSortable = false, IsFilterable = false, IsFacetable = false
},
new SearchField("fileType", SearchFieldDataType.String)
{
IsSearchable = true, IsSortable = false, IsFilterable = true, IsFacetable = true
},
new SearchField("keyPhrases", SearchFieldDataType.Collection(SearchFieldDataType.String))
{
IsSearchable = true, IsSortable = false, IsFilterable = true, IsFacetable = true
}
}
};
var suggester = new SearchSuggester("sg", new[] { "keyPhrases" });
index.Suggesters.Add(suggester);
await idxclient.CreateIndexAsync(index);
}
catch (Exception e)
{
log.LogError("init-accelerator: Error while creating index " + e.Message);
throw new Exception(e.Message);
}
}
public async Task DeleteAllAsync <T>(IGraphRequestContext graphRequestContext) where T : class
{
var client = Get <T>(graphRequestContext);
_logger.LogInformation($"Removing search index: {client.IndexName}");
await _searchServiceClient.DeleteIndexAsync(client.IndexName);
var fields = GetTypeFields(typeof(T), true);
await _searchServiceClient.CreateIndexAsync(new SearchIndex(client.IndexName, fields));
}
private static async Task <bool> CreateIndex()
{
Console.WriteLine("Creating Index...");
try
{
SearchIndex index = SearchResources.GetIndex(IndexName, SynonymMapName);
await _searchIndexClient.CreateIndexAsync(index);
}
catch (Exception ex)
{
if (DebugMode)
{
Console.WriteLine("Error creating index: {0}", ex.Message);
}
return(false);
}
return(true);
}
public async Task Upload()
{
var existingSearchTerms = (await _tableStorage.GetAllAsync <GlobalSearchTerm>("searchTerms")).ToList();
var i = 1;
Parallel.ForEach(existingSearchTerms, new ParallelOptions {
MaxDegreeOfParallelism = Environment.ProcessorCount
}, async existingSearchTerm =>
{
await _tableStorage.DeleteAsync("searchTerms", existingSearchTerm);
Console.WriteLine($"Deleted {i} of {existingSearchTerms.Count} existing search terms.");
i++;
});
foreach (var globalSearchTerm in _globalSearchTermRepository.SearchTerms)
{
globalSearchTerm.LanguageEnum = _localization.Language;
}
await _tableStorage.AddBatchAsync <GlobalSearchTerm>("searchTerms",
_globalSearchTermRepository.SearchTerms.Where(s =>
s.PartitionKey == ContentType.ExpandedContent.ToString()),
new BatchOperationOptions { BatchInsertMethod = BatchInsertMethod.Insert });
await _tableStorage.AddBatchAsync <GlobalSearchTerm>("searchTerms",
_globalSearchTermRepository.SearchTerms.Where(s =>
s.PartitionKey == ContentType.Core.ToString()),
new BatchOperationOptions { BatchInsertMethod = BatchInsertMethod.Insert });
var index = await _searchIndexClient.GetIndexAsync("searchterms-index");
await _searchIndexClient.DeleteIndexAsync("searchterms-index");
await _searchIndexClient.CreateIndexAsync(index);
var oldIndexer = await _searchIndexerClient.GetIndexerAsync("searchterms-indexer");
await _searchIndexerClient.DeleteIndexerAsync(oldIndexer);
await _searchIndexerClient.CreateIndexerAsync(oldIndexer);
await _searchIndexerClient.RunIndexerAsync("searchterms-indexer");
}
private async Task <SearchClient> CreateIndexAsync(SearchResources resources)
{
Environment.SetEnvironmentVariable("SEARCH_ENDPOINT", resources.Endpoint.ToString());
Environment.SetEnvironmentVariable("SEARCH_API_KEY", resources.PrimaryApiKey);
#region Snippet:Azure_Search_Documents_Tests_Samples_Sample05_IndexingDocuments_CreateIndex_Connect
Uri endpoint = new Uri(Environment.GetEnvironmentVariable("SEARCH_ENDPOINT"));
string key = Environment.GetEnvironmentVariable("SEARCH_API_KEY");
// Create a client for manipulating search indexes
AzureKeyCredential credential = new AzureKeyCredential(key);
SearchIndexClient indexClient = new SearchIndexClient(endpoint, credential);
#endregion
indexClient = InstrumentClient(new SearchIndexClient(endpoint, credential, GetSearchClientOptions()));
#region Snippet:Azure_Search_Documents_Tests_Samples_Sample05_IndexingDocuments_CreateIndex_Create
// Create the search index
string indexName = "Products";
#if !SNIPPET
indexName = Recording.Random.GetName();
#endif
await indexClient.CreateIndexAsync(
new SearchIndex(indexName)
{
Fields = new FieldBuilder().Build(typeof(Product))
});
#endregion
#region Snippet:Azure_Search_Documents_Tests_Samples_Sample05_IndexingDocuments_CreateIndex_Client
SearchClient searchClient = indexClient.GetSearchClient(indexName);
#endregion
searchClient = InstrumentClient(searchClient);
return(searchClient);
}
public async Task CreateIndexerAsync()
{
await using SearchResources resources = await SearchResources.CreateWithBlobStorageAsync(this, populate : true);
Environment.SetEnvironmentVariable("SEARCH_ENDPOINT", resources.Endpoint.ToString());
Environment.SetEnvironmentVariable("SEARCH_API_KEY", resources.PrimaryApiKey);
Environment.SetEnvironmentVariable("STORAGE_CONNECTION_STRING", resources.StorageAccountConnectionString);
Environment.SetEnvironmentVariable("STORAGE_CONTAINER", resources.BlobContainerName);
Environment.SetEnvironmentVariable("COGNITIVE_SERVICES_KEY", resources.CognitiveServicesKey);
// Define clean up tasks to be invoked in reverse order added.
Stack <Func <Task> > cleanUpTasks = new Stack <Func <Task> >();
try
{
#region Snippet:Azure_Search_Tests_Samples_CreateIndexerAsync_CreateSynonymMap
// Create a new SearchIndexClient
Uri endpoint = new Uri(Environment.GetEnvironmentVariable("SEARCH_ENDPOINT"));
AzureKeyCredential credential = new AzureKeyCredential(
Environment.GetEnvironmentVariable("SEARCH_API_KEY"));
SearchIndexClient indexClient = new SearchIndexClient(endpoint, credential);
#if !SNIPPET
indexClient = resources.GetIndexClient(new SearchClientOptions());
#endif
// Create a synonym map from a file containing country names and abbreviations
// using the Solr format with entry on a new line using \n, for example:
// United States of America,US,USA\n
string synonymMapName = "countries";
#if !SNIPPET
synonymMapName = Recording.Random.GetName();
#endif
string synonymMapPath = "countries.txt";
#if !SNIPPET
synonymMapPath = Path.Combine(TestContext.CurrentContext.TestDirectory, "Samples", "countries.txt");
#endif
SynonymMap synonyms;
#if SNIPPET
using (StreamReader file = File.OpenText(synonymMapPath))
{
synonyms = new SynonymMap(synonymMapName, file);
}
#else
synonyms = new SynonymMap(synonymMapName, CountriesSolrSynonymMap);
#endif
await indexClient.CreateSynonymMapAsync(synonyms);
#endregion Snippet:Azure_Search_Tests_Samples_CreateIndexerAsync_CreateSynonymMap
// Make sure our synonym map gets deleted, which is not deleted when our
// index is deleted when our SearchResources goes out of scope.
cleanUpTasks.Push(() => indexClient.DeleteSynonymMapAsync(synonymMapName));
#region Snippet:Azure_Search_Tests_Samples_CreateIndexerAsync_CreateIndex
// Create the index
string indexName = "hotels";
#if !SNIPPET
indexName = Recording.Random.GetName();
#endif
SearchIndex index = new SearchIndex(indexName)
{
Fields =
{
new SimpleField("hotelId", SearchFieldDataType.String)
{
IsKey = true, IsFilterable = true, IsSortable = true
},
new SearchableField("hotelName")
{
IsFilterable = true, IsSortable = true
},
new SearchableField("description")
{
AnalyzerName = LexicalAnalyzerName.EnLucene
},
new SearchableField("descriptionFr")
{
AnalyzerName = LexicalAnalyzerName.FrLucene
},
new SearchableField("tags", collection: true)
{
IsFilterable = true, IsFacetable = true
},
new ComplexField("address")
{
Fields =
{
new SearchableField("streetAddress"),
new SearchableField("city")
{
IsFilterable = true, IsSortable = true, IsFacetable = true
},
new SearchableField("stateProvince")
{
IsFilterable = true, IsSortable = true, IsFacetable = true
},
new SearchableField("country")
{
SynonymMapNames = new[] { synonymMapName },IsFilterable = true, IsSortable = true,IsFacetable = true
},
new SearchableField("postalCode")
{
IsFilterable = true, IsSortable = true, IsFacetable = true
}
}
}
}
};
await indexClient.CreateIndexAsync(index);
#endregion Snippet:Azure_Search_Tests_Samples_CreateIndexerAsync_CreateIndex
// Make sure our synonym map gets deleted, which is not deleted when our
// index is deleted when our SearchResources goes out of scope.
cleanUpTasks.Push(() => indexClient.DeleteIndexAsync(indexName));
#region Snippet:Azure_Search_Tests_Samples_CreateIndexerAsync_CreateDataSourceConnection
// Create a new SearchIndexerClient
SearchIndexerClient indexerClient = new SearchIndexerClient(endpoint, credential);
#if !SNIPPET
indexerClient = resources.GetIndexerClient();
#endif
string dataSourceConnectionName = "hotels";
#if !SNIPPET
dataSourceConnectionName = Recording.Random.GetName();
#endif
SearchIndexerDataSourceConnection dataSourceConnection = new SearchIndexerDataSourceConnection(
dataSourceConnectionName,
SearchIndexerDataSourceType.AzureBlob,
Environment.GetEnvironmentVariable("STORAGE_CONNECTION_STRING"),
new SearchIndexerDataContainer(Environment.GetEnvironmentVariable("STORAGE_CONTAINER")));
await indexerClient.CreateDataSourceConnectionAsync(dataSourceConnection);
#endregion Snippet:Azure_Search_Tests_Samples_CreateIndexerAsync_CreateDataSourceConnection
// Make sure our data source gets deleted, which is not deleted when our
// index is deleted when our SearchResources goes out of scope.
cleanUpTasks.Push(() => indexerClient.DeleteDataSourceConnectionAsync(dataSourceConnectionName));
#region Snippet:Azure_Search_Tests_Samples_CreateIndexerAsync_Skillset
// Translate English descriptions to French.
// See https://docs.microsoft.com/azure/search/cognitive-search-skill-text-translation for details of the Text Translation skill.
TextTranslationSkill translationSkill = new TextTranslationSkill(
inputs: new[]
{
new InputFieldMappingEntry("text")
{
Source = "/document/description"
}
},
outputs: new[]
{
new OutputFieldMappingEntry("translatedText")
{
TargetName = "descriptionFrTranslated"
}
},
TextTranslationSkillLanguage.Fr)
{
Name = "descriptionFrTranslation",
Context = "/document",
DefaultFromLanguageCode = TextTranslationSkillLanguage.En
};
// Use the human-translated French description if available; otherwise, use the translated description.
// See https://docs.microsoft.com/azure/search/cognitive-search-skill-conditional for details of the Conditional skill.
ConditionalSkill conditionalSkill = new ConditionalSkill(
inputs: new[]
{
new InputFieldMappingEntry("condition")
{
Source = "= $(/document/descriptionFr) == null"
},
new InputFieldMappingEntry("whenTrue")
{
Source = "/document/descriptionFrTranslated"
},
new InputFieldMappingEntry("whenFalse")
{
Source = "/document/descriptionFr"
}
},
outputs: new[]
{
new OutputFieldMappingEntry("output")
{
TargetName = "descriptionFrFinal"
}
})
{
Name = "descriptionFrConditional",
Context = "/document",
};
// Create a SearchIndexerSkillset that processes those skills in the order given below.
string skillsetName = "translations";
#if !SNIPPET
skillsetName = Recording.Random.GetName();
#endif
SearchIndexerSkillset skillset = new SearchIndexerSkillset(
skillsetName,
new SearchIndexerSkill[] { translationSkill, conditionalSkill })
{
CognitiveServicesAccount = new CognitiveServicesAccountKey(
Environment.GetEnvironmentVariable("COGNITIVE_SERVICES_KEY")),
KnowledgeStore = new SearchIndexerKnowledgeStore(
Environment.GetEnvironmentVariable("STORAGE_CONNECTION_STRING"),
new List <SearchIndexerKnowledgeStoreProjection>()),
};
await indexerClient.CreateSkillsetAsync(skillset);
#endregion Snippet:Azure_Search_Tests_Samples_CreateIndexerAsync_Skillset
// Make sure our skillset gets deleted, which is not deleted when our
// index is deleted when our SearchResources goes out of scope.
cleanUpTasks.Push(() => indexerClient.DeleteSkillsetAsync(skillsetName));
#region Snippet:Azure_Search_Tests_Samples_CreateIndexerAsync_CreateIndexer
string indexerName = "hotels";
#if !SNIPPET
indexerName = Recording.Random.GetName();
#endif
SearchIndexer indexer = new SearchIndexer(
indexerName,
dataSourceConnectionName,
indexName)
{
// We only want to index fields defined in our index, excluding descriptionFr if defined.
FieldMappings =
{
new FieldMapping("hotelId"),
new FieldMapping("hotelName"),
new FieldMapping("description"),
new FieldMapping("tags"),
new FieldMapping("address")
},
OutputFieldMappings =
{
new FieldMapping("/document/descriptionFrFinal")
{
TargetFieldName = "descriptionFr"
}
},
Parameters = new IndexingParameters
{
// Tell the indexer to parse each blob as a separate JSON document.
IndexingParametersConfiguration = new IndexingParametersConfiguration
{
ParsingMode = BlobIndexerParsingMode.Json
}
},
SkillsetName = skillsetName
};
// Create the indexer which, upon successful creation, also runs the indexer.
await indexerClient.CreateIndexerAsync(indexer);
#endregion Snippet:Azure_Search_Tests_Samples_CreateIndexerAsync_CreateIndexer
// Make sure our indexer gets deleted, which is not deleted when our
// index is deleted when our SearchResources goes out of scope.
cleanUpTasks.Push(() => indexerClient.DeleteIndexerAsync(indexerName));
// Wait till the indexer is done.
await WaitForIndexingAsync(indexerClient, indexerName);
#region Snippet:Azure_Search_Tests_Samples_CreateIndexerAsync_Query
// Get a SearchClient from the SearchIndexClient to share its pipeline.
SearchClient searchClient = indexClient.GetSearchClient(indexName);
#if !SNIPPET
searchClient = InstrumentClient(new SearchClient(endpoint, indexName, credential, GetSearchClientOptions()));
#endif
// Query for hotels with an ocean view.
SearchResults <Hotel> results = await searchClient.SearchAsync <Hotel>("ocean view");
#if !SNIPPET
bool found = false;
#endif
await foreach (SearchResult <Hotel> result in results.GetResultsAsync())
{
Hotel hotel = result.Document;
#if !SNIPPET
if (hotel.HotelId == "6")
{
Assert.IsNotNull(hotel.DescriptionFr); found = true;
}
#endif
Console.WriteLine($"{hotel.HotelName} ({hotel.HotelId})");
Console.WriteLine($" Description (English): {hotel.Description}");
Console.WriteLine($" Description (French): {hotel.DescriptionFr}");
}
#endregion Snippet:Azure_Search_Tests_Samples_CreateIndexerAsync_Query
Assert.IsTrue(found, "Expected hotel #6 not found in search results");
}
finally
{
// We want to await these individual to create a deterministic order for playing back tests.
foreach (Func <Task> cleanUpTask in cleanUpTasks)
{
await cleanUpTask();
}
}
}