public void CheckSearchParameter(
string resourceType,
IEnumerable <SearchParameterInfo> parameters)
{
SearchParameterToTypeResolver.Log = s => _outputHelper.WriteLine(s);
foreach (var parameterInfo in parameters)
{
var fhirPath = parameterInfo.Expression;
var parameterName = parameterInfo.Name;
var searchParamType = parameterInfo.Type;
_outputHelper.WriteLine("** Evaluating: " + fhirPath);
var converters =
GetConvertsForSearchParameters(resourceType, parameterInfo);
Assert.True(
converters.Any(x => x.hasConverter),
$"{parameterName} ({resourceType}) was not able to be mapped.");
string listedTypes = string.Join(",", converters.Select(x => x.result.ClassMapping.NativeType.Name));
_outputHelper.WriteLine($"Info: {parameterName} ({searchParamType}) found {listedTypes} types ({converters.Count}).");
foreach (var result in converters.Where(x => x.hasConverter || !parameterInfo.IsPartiallySupported))
{
var found = SearchParameterFixtureData.Manager.TryGetConverter(result.result.ClassMapping.NativeType, SearchIndexer.GetSearchValueTypeForSearchParamType(result.result.SearchParamType), out var converter);
var converterText = found ? converter.GetType().Name : "None";
string searchTermMapping = $"Search term '{parameterName}' ({result.result.SearchParamType}) mapped to '{result.result.ClassMapping.NativeType.Name}', converter: {converterText}";
_outputHelper.WriteLine(searchTermMapping);
Assert.True(found, searchTermMapping);
}
}
}
public async Task <Response <SearchIndexer> > CreateOrUpdateAsync(string indexerName, SearchIndexer indexer, string ifMatch = null, string ifNoneMatch = null, CancellationToken cancellationToken = default)
{
if (indexerName == null)
{
throw new ArgumentNullException(nameof(indexerName));
}
if (indexer == null)
{
throw new ArgumentNullException(nameof(indexer));
}
using var message = CreateCreateOrUpdateRequest(indexerName, indexer, ifMatch, ifNoneMatch);
await _pipeline.SendAsync(message, cancellationToken).ConfigureAwait(false);
switch (message.Response.Status)
{
case 200:
case 201:
{
SearchIndexer value = default;
using var document = await JsonDocument.ParseAsync(message.Response.ContentStream, default, cancellationToken).ConfigureAwait(false);
value = SearchIndexer.DeserializeSearchIndexer(document.RootElement);
return(Response.FromValue(value, message.Response));
}
public async ValueTask <Response <SearchIndexer> > CreateOrUpdateAsync(string indexerName, SearchIndexer indexer, Guid?xMsClientRequestId = null, string ifMatch = null, string ifNoneMatch = null, CancellationToken cancellationToken = default)
{
if (indexerName == null)
{
throw new ArgumentNullException(nameof(indexerName));
}
if (indexer == null)
{
throw new ArgumentNullException(nameof(indexer));
}
using var scope = _clientDiagnostics.CreateScope("IndexersClient.CreateOrUpdate");
scope.Start();
try
{
using var message = CreateCreateOrUpdateRequest(indexerName, indexer, xMsClientRequestId, ifMatch, ifNoneMatch);
await _pipeline.SendAsync(message, cancellationToken).ConfigureAwait(false);
switch (message.Response.Status)
{
case 200:
case 201:
{
SearchIndexer value = default;
using var document = await JsonDocument.ParseAsync(message.Response.ContentStream, default, cancellationToken).ConfigureAwait(false);
if (document.RootElement.ValueKind == JsonValueKind.Null)
{
value = null;
}
else
{
value = SearchIndexer.DeserializeSearchIndexer(document.RootElement);
}
return(Response.FromValue(value, message.Response));
}
public async Task CreateDoubleEncryptedIndex()
{
string keyVaultUrl = TestEnvironment.KeyVaultUrl;
if (string.IsNullOrEmpty(keyVaultUrl))
{
Assert.Ignore("A Key Vault was not deployed");
}
// Create the key and persist the name and version.
KeyVaultKey key = await CreateEncryptionKey(keyVaultUrl);
Environment.SetEnvironmentVariable("KEYVAULT_URL", keyVaultUrl);
Environment.SetEnvironmentVariable("KEYVAULT_KEY_NAME", key.Name);
Environment.SetEnvironmentVariable("KEYVAULT_KEY_VERSION", key.Properties.Version);
// Persist the service principal.
Environment.SetEnvironmentVariable("APPLICATION_ID", TestEnvironment.ClientId);
Environment.SetEnvironmentVariable("APPLICATION_SECRET", TestEnvironment.RecordedClientSecret);
// Create the blob container and persist connection information.
await using SearchResources resources = await SearchResources.CreateWithBlobStorageAndIndexAsync(this, populate : true);
Environment.SetEnvironmentVariable("STORAGE_CONNECTION_STRING", resources.StorageAccountConnectionString);
Environment.SetEnvironmentVariable("STORAGE_CONTAINER_NAME", resources.BlobContainerName);
Environment.SetEnvironmentVariable("SEARCH_ENDPOINT", resources.Endpoint.ToString());
Environment.SetEnvironmentVariable("SEARCH_API_KEY", resources.PrimaryApiKey);
// 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_Sample06_EncryptedIndex_CreateDoubleEncryptedIndex_Index
// Create a credential to connect to Key Vault and use a specific key version created previously.
SearchResourceEncryptionKey encryptionKey = new SearchResourceEncryptionKey(
new Uri(Environment.GetEnvironmentVariable("KEYVAULT_URL")),
Environment.GetEnvironmentVariable("KEYVAULT_KEY_NAME"),
Environment.GetEnvironmentVariable("KEYVAULT_KEY_VERSION"))
{
ApplicationId = Environment.GetEnvironmentVariable("APPLICATION_ID"),
ApplicationSecret = Environment.GetEnvironmentVariable("APPLICATION_SECRET"),
};
// Create a connection to our storage blob container using the credential.
string dataSourceConnectionName = "hotels-data-source";
/*@@*/ dataSourceConnectionName = Recording.Random.GetName();
SearchIndexerDataSourceConnection dataSourceConnection = new SearchIndexerDataSourceConnection(
dataSourceConnectionName,
SearchIndexerDataSourceType.AzureBlob,
Environment.GetEnvironmentVariable("STORAGE_CONNECTION_STRING"),
new SearchIndexerDataContainer(
Environment.GetEnvironmentVariable("STORAGE_CONTAINER_NAME")
)
)
{
EncryptionKey = encryptionKey
};
// Create an indexer to process documents from the blob container into the index.
// You can optionally configure a skillset to use cognitive services when processing documents.
// Set the SearchIndexerSkillset.EncryptionKey to the same credential if you use a skillset.
string indexName = "hotels";
/*@@*/ indexName = resources.IndexName;
string indexerName = "hotels-indexer";
/*@@*/ indexerName = Recording.Random.GetName();
SearchIndexer indexer = new SearchIndexer(
indexerName,
dataSourceConnectionName,
indexName)
{
EncryptionKey = encryptionKey,
// Map the fields in our documents we want to index.
FieldMappings =
{
new FieldMapping("hotelId"),
new FieldMapping("hotelName"),
new FieldMapping("description"),
new FieldMapping("tags"),
new FieldMapping("address")
},
Parameters = new IndexingParameters
{
// Tell the indexer to parse each blob as a separate JSON document.
IndexingParametersConfiguration = new IndexingParametersConfiguration
{
ParsingMode = BlobIndexerParsingMode.Json
}
}
};
// Now connect to our Search service and set up the data source and indexer.
// Documents already in the storage blob will begin indexing immediately.
Uri endpoint = new Uri(Environment.GetEnvironmentVariable("SEARCH_ENDPOINT"));
AzureKeyCredential credential = new AzureKeyCredential(
Environment.GetEnvironmentVariable("SEARCH_API_KEY"));
SearchIndexerClient indexerClient = new SearchIndexerClient(endpoint, credential);
/*@@*/ indexerClient = resources.GetIndexerClient();
indexerClient.CreateDataSourceConnection(dataSourceConnection);
/*@@*/ cleanUpTasks.Push(() => indexerClient.DeleteDataSourceConnectionAsync(dataSourceConnectionName));
indexerClient.CreateIndexer(indexer);
/*@@*/ cleanUpTasks.Push(() => indexerClient.DeleteIndexerAsync(indexerName));
#endregion Snippet:Azure_Search_Tests_Sample06_EncryptedIndex_CreateDoubleEncryptedIndex_Index
await WaitForIndexingAsync(indexerClient, indexerName);
#region Snippet:Azure_Search_Tests_Sample06_EncryptedIndex_CreateDoubleEncryptedIndex_Query
// Create a SearchClient and search for luxury hotels. In production, be sure to use the query key.
SearchClient searchClient = new SearchClient(endpoint, "hotels", credential);
/*@@*/ searchClient = resources.GetSearchClient();
/*@@*/ bool found = false;
Response <SearchResults <Hotel> > results = searchClient.Search <Hotel>("luxury hotels");
foreach (SearchResult <Hotel> result in results.Value.GetResults())
{
Hotel hotel = result.Document;
/*@@*/ found = true;
Console.WriteLine($"{hotel.HotelName} ({hotel.HotelId})");
Console.WriteLine($" Description: {hotel.Description}");
}
#endregion Snippet:Azure_Search_Tests_Sample06_EncryptedIndex_CreateDoubleEncryptedIndex_Query
Assert.IsTrue(found, "No luxury hotels were found in index");
}
finally
{
// We want to await these individual to create a deterministic order for playing back tests.
foreach (Func <Task> cleanUpTask in cleanUpTasks)
{
await cleanUpTask();
}
}
}
public void CreateDataSource()
{
//creating index
SearchIndexClient indexClient = new SearchIndexClient(Uri, keyCredential);
SearchIndexerClient indexerClient = new SearchIndexerClient(Uri, keyCredential);
Console.WriteLine("Creating index...");
FieldBuilder fieldBuilder = new FieldBuilder();
var searchFields = fieldBuilder.Build(typeof(InteractionDetails));
var searchIndex = new SearchIndex("interaction-sql-idx", searchFields);
// If we have run the sample before, this index will be populated
// We can clear the index by deleting it if it exists and creating
// it again
CleanupSearchIndexClientResources(indexClient, searchIndex);
indexClient.CreateOrUpdateIndexAsync(searchIndex);
//Creating data source
Console.WriteLine("Creating data source...");
var dataSource =
new SearchIndexerDataSourceConnection(
"interaction-sql-ds",
SearchIndexerDataSourceType.AzureSql,
azureSQLConnectionStr,
new SearchIndexerDataContainer("[Interaction]"));
indexerClient.CreateOrUpdateDataSourceConnection(dataSource);
//Creating indexer
Console.WriteLine("Creating Azure SQL indexer...");
//var schedule = new IndexingSchedule(TimeSpan.FromDays(1))
//{
// StartTime = DateTimeOffset.Now
//};
var parameters = new IndexingParameters()
{
BatchSize = 100,
MaxFailedItems = 0,
MaxFailedItemsPerBatch = 0
};
// Indexer declarations require a data source and search index.
// Common optional properties include a schedule, parameters, and field mappings
// The field mappings below are redundant due to how the Hotel class is defined, but
// we included them anyway to show the syntax
var indexer = new SearchIndexer("interaction-sql-idxr", dataSource.Name, searchIndex.Name)
{
Description = "Data indexer",
Schedule = new IndexingSchedule(TimeSpan.FromMinutes(5)),
Parameters = parameters,
};
indexerClient.CreateOrUpdateIndexerAsync(indexer);
Console.WriteLine("Running Azure SQL indexer...");
try
{
indexerClient.RunIndexerAsync(indexer.Name);
}
catch (CloudException e) when(e.Response.StatusCode == (HttpStatusCode)429)
{
Console.WriteLine("Failed to run indexer: {0}", e.Response.Content);
}
// Wait 5 seconds for indexing to complete before checking status
Console.WriteLine("Waiting for indexing...\n");
System.Threading.Thread.Sleep(5000);
}
private static void SearchAssets(SearchContext context, List <SearchItem> items, SearchProvider provider, SearchIndexer fileIndexer)
{
var filter = context.searchQuery;
var searchPackages = context.categories.Any(c => c.name.id == "packages" && c.isEnabled);
var searchGuids = context.categories.Any(c => c.name.id == "guid" && c.isEnabled);
if (searchGuids)
{
var gui2Path = AssetDatabase.GUIDToAssetPath(filter);
if (!System.String.IsNullOrEmpty(gui2Path))
{
items.Add(provider.CreateItem(gui2Path, -1, $"{Path.GetFileName(gui2Path)} ({filter})", null, null, null));
}
}
if (fileIndexer.IsReady())
{
if (filter.IndexOfAny(k_InvalidIndexedChars) == -1)
{
items.AddRange(fileIndexer.Search(filter, searchPackages ? int.MaxValue : 100).Take(201)
.Select(e =>
{
var filename = Path.GetFileName(e.path);
var filenameNoExt = Path.GetFileNameWithoutExtension(e.path);
var itemScore = e.score;
if (filenameNoExt.Equals(filter, StringComparison.InvariantCultureIgnoreCase))
{
itemScore = SearchProvider.k_RecentUserScore + 1;
}
return(provider.CreateItem(e.path, itemScore, filename, null, null, null));
}));
if (!context.wantsMore)
{
return;
}
}
}
if (!searchPackages)
{
if (!filter.Contains("a:assets"))
{
filter = "a:assets " + filter;
}
}
items.AddRange(AssetDatabase.FindAssets(filter)
.Select(AssetDatabase.GUIDToAssetPath)
.Take(202)
.Select(path => provider.CreateItem(path, Path.GetFileName(path))));
if (context.searchQuery.Contains('*'))
{
var safeFilter = string.Join("_", context.searchQuery.Split(k_InvalidSearchFileChars));
items.AddRange(Directory.EnumerateFiles(Application.dataPath, safeFilter, SearchOption.AllDirectories)
.Select(path => provider.CreateItem(path.Replace(Application.dataPath, "Assets").Replace("\\", "/"),
Path.GetFileName(path))));
}
}
private static void RunThreadIndexing()
{
var sw = new System.Diagnostics.Stopwatch();
sw.Start();
index = new SearchIndexer();
index.Start();
int completed = 0;
var metaFiles = Directory.GetFiles("Assets", "*.meta", SearchOption.AllDirectories);
var progressId = Progress.Start($"Scanning dependencies ({metaFiles.Length} assets)");
Parallel.ForEach(metaFiles, mf =>
{
Progress.Report(progressId, completed / (float)metaFiles.Length, mf);
var assetPath = mf.Replace("\\", "/").Substring(0, mf.Length - 5).ToLowerInvariant();
if (!File.Exists(assetPath))
{
return;
}
var guid = ToGuid(assetPath);
Progress.Report(progressId, completed / (float)metaFiles.Length, assetPath);
TrackGuid(guid);
pathToGuidMap.TryAdd(assetPath, guid);
guidToPathMap.TryAdd(guid, assetPath);
var mfc = File.ReadAllText(mf);
ScanDependencies(guid, mfc);
using (var file = new StreamReader(assetPath))
{
var header = new char[5];
if (file.ReadBlock(header, 0, header.Length) == header.Length &&
header[0] == '%' && header[1] == 'Y' && header[2] == 'A' && header[3] == 'M' && header[4] == 'L')
{
var ac = file.ReadToEnd();
ScanDependencies(guid, ac);
}
}
Progress.Report(progressId, ++completed / (float)metaFiles.Length);
});
Progress.Finish(progressId, Progress.Status.Succeeded);
completed = 0;
var total = pathToGuidMap.Count + guidToRefsMap.Count + guidFromRefsMap.Count;
progressId = Progress.Start($"Indexing {total} dependencies");
foreach (var kvp in pathToGuidMap)
{
var guid = kvp.Value;
var path = kvp.Key;
var ext = Path.GetExtension(path);
if (ext.Length > 0 && ext[0] == '.')
{
ext = ext.Substring(1);
}
Progress.Report(progressId, completed++ / (float)total, path);
var di = AddGuid(guid);
index.AddExactWord("all", 0, di);
AddStaticProperty("id", guid, di, exact: true);
AddStaticProperty("path", path, di, exact: true);
AddStaticProperty("t", GetExtension(path).ToLowerInvariant(), di);
index.AddWord(guid, guid.Length, 0, di);
IndexWordComponents(di, path);
}
foreach (var kvp in guidToRefsMap)
{
var guid = kvp.Key;
var refs = kvp.Value.Keys;
var di = AddGuid(guid);
index.AddWord(guid, guid.Length, 0, di);
Progress.Report(progressId, completed++ / (float)total, guid);
index.AddNumber("out", refs.Count, 0, di);
foreach (var r in refs)
{
AddStaticProperty("to", r, di);
}
}
foreach (var kvp in guidFromRefsMap)
{
var guid = kvp.Key;
var refs = kvp.Value.Keys;
var di = AddGuid(guid);
Progress.Report(progressId, completed++ / (float)total, guid);
index.AddNumber("in", refs.Count, 0, di);
foreach (var r in refs)
{
AddStaticProperty("from", r, di);
}
if (guidToPathMap.TryGetValue(guid, out var path))
{
AddStaticProperty("is", "valid", di);
}
else
{
AddStaticProperty("is", "missing", di);
foreach (var r in refs)
{
var refDocumentIndex = AddGuid(r);
AddStaticProperty("is", "broken", refDocumentIndex);
var refDoc = index.GetDocument(refDocumentIndex);
if (refDoc.metadata == null)
{
refDoc.metadata = $"Broken links {guid}";
}
else
{
refDoc.metadata += $", {guid}";
}
}
var refString = string.Join(", ", refs.Select(r =>
{
if (guidToPathMap.TryGetValue(r, out var rp))
{
return(rp);
}
return(r);
}));
index.GetDocument(di).metadata = $"Refered by {refString}";
}
}
Progress.SetDescription(progressId, $"Saving dependency index at {dependencyIndexLibraryPath}");
index.Finish((bytes) =>
{
File.WriteAllBytes(dependencyIndexLibraryPath, bytes);
Progress.Finish(progressId, Progress.Status.Succeeded);
Debug.Log($"Dependency indexing took {sw.Elapsed.TotalMilliseconds,3:0.##} ms " +
$"and was saved at {dependencyIndexLibraryPath} ({EditorUtility.FormatBytes(bytes.Length)} bytes)");
}, removedDocuments: null);
}
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();
#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"))
};
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();
}
}
}
public TaskData(byte[] bytes, SearchIndexer combinedIndex)
{
this.bytes = bytes;
this.combinedIndex = combinedIndex;
}
