private static async Task DeleteIndexIfExists(ISearchServiceClient serviceClient, string indexName)
{
if (await serviceClient.Indexes.ExistsAsync(indexName))
{
await serviceClient.Indexes.DeleteAsync(indexName);
}
}
private static void DeleteHotelsIndexIfExists(ISearchServiceClient searchClient, string index_name)
{
if (searchClient.Indexes.Exists("index_name"))
{
searchClient.Indexes.Delete("index_name");
}
}
private static async Task DeleteSkillsetIfExists(ISearchServiceClient serviceClient, string skillsetName)
{
if (await serviceClient.Skillsets.ExistsAsync(skillsetName))
{
await serviceClient.Skillsets.DeleteAsync(skillsetName);
}
}
/// <summary>
/// Creates the Index, Indexer, and Skillset for the cognitive search pipeline.
/// </summary>
public static async Task CreateCognitiveSearchPipeline(ISearchServiceClient searchClient, SearchConfig searchConfig, Index index, Indexer indexer, Skillset skillset)
{
try
{
// Delete the existing Index, Indexer and Skillset
await DeleteIndexerIfExists(searchClient, indexer.Name);
await DeleteSkillsetIfExists(searchClient, skillset.Name);
await DeleteIndexIfExists(searchClient, index.Name);
// Create a new Index, Indexer and Skillset.
// Currently, the SDK is broken in how it handles Http Headers, so if using a custom WebApiSkill, send to the REST API, and don't use the SDK service.
if (skillset.Skills.Any(s => s.GetType().Name == "WebApiSkill"))
{
await CreateSkillsetViaApi(searchConfig, skillset);
}
else
{
await CreateSkillset(searchClient, skillset);
}
await CreateIndex(searchClient, index);
await CreateIndexer(searchClient, indexer);
}
catch
{
throw;
}
}
public UnitPopulationService(
ISearchServiceClient searchServiceClient,
IPopulationConfiguration populationConfiguration,
ILarsContextFactory contextFactory,
IAcademicYearService academicYearService,
IIssuingAuthorityService issuingAuthorityService,
IComponentTypeService componentTypeService,
IFundingService fundingService,
IValidityService validityService,
ILearningDeliveryCategoryService learningDeliveryCategoryService,
IFrameworkAimService frameworkAimService,
IEntitlementCategoryService entitlementCategoryService,
IAwardOrgService awardOrgService)
: base(
searchServiceClient,
populationConfiguration,
contextFactory,
academicYearService,
issuingAuthorityService,
componentTypeService,
fundingService,
validityService,
learningDeliveryCategoryService,
frameworkAimService,
entitlementCategoryService,
awardOrgService)
{
}
public async Task SearchById_GivenIdDoesNotReturnSearchResult_ReturnsNull()
{
SearchRepositorySettings searchRepositorySettings = new SearchRepositorySettings
{
SearchKey = string.Empty,
SearchServiceName = string.Empty
};
ISearchInitializer searchInitializer = Substitute.For <ISearchInitializer>();
ISearchIndexClient searchIndexClient = Substitute.For <ISearchIndexClient>();
AzureOperationResponse <DocumentSearchResult <SpecificationIndex> > documentSearchResult =
new AzureOperationResponse <DocumentSearchResult <SpecificationIndex> >
{
Body = new DocumentSearchResult <SpecificationIndex>(null, null, null, null, null)
};
IDocumentsOperations documentsOperations = Substitute.For <IDocumentsOperations>();
documentsOperations.SearchWithHttpMessagesAsync <SpecificationIndex>(Arg.Any <string>(), Arg.Any <SearchParameters>()).Returns(Task.FromResult(documentSearchResult));
ISearchServiceClient searchServiceClient = Substitute.For <ISearchServiceClient>();
searchIndexClient.Documents.Returns(documentsOperations);
SearchRepository <SpecificationIndex> searchRepository = new SearchRepository <SpecificationIndex>(searchRepositorySettings, searchInitializer, searchServiceClient, searchIndexClient);
string notFoundId = "notFound";
SpecificationIndex specificationIndex = await searchRepository.SearchById(notFoundId);
specificationIndex.Should().BeNull();
}
static void Main(string[] args)
{
DataSourceName = ConfigurationManager.AppSettings["DataSourceName"];
IndexName = ConfigurationManager.AppSettings["IndexName"];
SkillsetName = ConfigurationManager.AppSettings["SkillsetName"];
IndexerName = ConfigurationManager.AppSettings["IndexerName"];
SynonymMapName = ConfigurationManager.AppSettings["SynonymMapName"];
BlobContainerNameForImageStore = ConfigurationManager.AppSettings["BlobContainerNameForImageStore"];
string searchServiceName = ConfigurationManager.AppSettings["SearchServiceName"];
string apiKey = ConfigurationManager.AppSettings["SearchServiceApiKey"];
_searchClient = new SearchServiceClient(searchServiceName, new SearchCredentials(apiKey));
bool result = RunAsync().GetAwaiter().GetResult();
if (!result && !DebugMode)
{
Console.WriteLine("Something went wrong. Set 'DebugMode' to true in order to see traces.");
}
else if (!result)
{
Console.WriteLine("Something went wrong.");
}
else
{
Console.WriteLine("All operations were successful.");
}
Console.WriteLine("Press any key to exit.");
Console.ReadKey();
}
public VehicleToBodyStyleConfigIndexingRepositoryService(ISearchServiceClient searchServiceClient = null)
{
_searchServiceClient = searchServiceClient ??
new SearchServiceClient("optimussearch",
new SearchCredentials("24C77889585CFB6E756E7783DE693438"));
_vehicleToBodyStyleConfigService = _searchServiceClient.Indexes.GetClient("vehicletobodystyleconfigs");
}
/// <summary>
/// Creates the index of the search.
/// </summary>
/// <param name="searchIndex">Index of the search.</param>
/// <param name="serviceClient">The service client.</param>
private static void CreateSearchIndex(string searchIndex, ISearchServiceClient serviceClient)
{
var definition = new Index
{
Name = searchIndex,
Fields = new[]
{
new Field("blogId", DataType.String)
{
IsKey = true
},
new Field("title", DataType.String)
{
IsSearchable = true,
IsFilterable = true
},
new Field("searchTags", DataType.Collection(DataType.String))
{
IsSearchable = true,
IsFilterable = true,
IsFacetable = true
}
}
};
serviceClient.Indexes.Create(definition);
}
/// <summary>
/// Creates the index if not exists.
/// </summary>
/// <param name="searchIndex">Index of the search.</param>
/// <param name="serviceClient">The service client.</param>
private static void CreateIndexIfNotExists(string searchIndex, ISearchServiceClient serviceClient)
{
if (!serviceClient.Indexes.Exists(searchIndex))
{
CreateSearchIndex(searchIndex, serviceClient);
}
}
public VehicleToMfrBodyCodeIndexingRepositoryService(ISearchServiceClient searchServiceClient = null)
{
_searchServiceClient = searchServiceClient ??
new SearchServiceClient("optimussearch",
new SearchCredentials("24C77889585CFB6E756E7783DE693438"));
_vehicleToMfrBodyCodeService = _searchServiceClient.Indexes.GetClient("vehicletomfrbodycodes");
}
/// <summary>
/// Sets the provided instance as the client for search service communication.
/// </summary>
/// <param name="repositoryBuilder">The <see cref="IRepositoryBuilder"/> instance.</param>
/// <param name="serviceClient">The client instance.</param>
public static IRepositoryBuilder UseLucene29CentralizedServiceClient(this IRepositoryBuilder repositoryBuilder,
ISearchServiceClient serviceClient)
{
SearchServiceClient.Instance = serviceClient;
return(repositoryBuilder);
}
public static async Task UpdateNuGetSearchIndexAsync(
this ISearchServiceClient client,
SearchScorerSettings settings,
Index index,
double packageIdWeight,
double tokenizedPackageIdWeight,
double tagsWeight,
double downloadScoreBoost)
{
Console.WriteLine($"Updating Azure Search service '{settings.AzureSearchServiceName}', index '{settings.AzureSearchIndexName}'");
Console.WriteLine($"Package ID weight: {packageIdWeight}");
Console.WriteLine($"Tokenized package ID weight: {tokenizedPackageIdWeight}");
Console.WriteLine($"Tags weight: {tagsWeight}");
Console.WriteLine($"Download score boost: {downloadScoreBoost}");
index.EnsureValidNuGetSearchIndex(settings);
var indexFieldWeights = index.ScoringProfiles[0].TextWeights.Weights;
var downloadScoreFunction = index.ScoringProfiles[0].Functions[0];
indexFieldWeights.Clear();
indexFieldWeights[PackageIdFieldName] = packageIdWeight;
indexFieldWeights[TokenizedPackageIdFieldName] = tokenizedPackageIdWeight;
indexFieldWeights[TagsFieldName] = tagsWeight;
downloadScoreFunction.Boost = downloadScoreBoost;
await client.Indexes.CreateOrUpdateAsync(index);
Console.WriteLine($"Updated Azure Search service '{settings.AzureSearchServiceName}', index '{settings.AzureSearchIndexName}'");
}
/// <summary>
/// Creates new Indexer with INDEXER_NAME provided, if already exist no change happen.
/// </summary>
/// <param name="searchClient">Search client.</param>
private async Task CreateIndexerAsync(ISearchServiceClient searchClient)
{
if (await searchClient.Indexers.ExistsAsync(this.indexName).ConfigureAwait(false))
{
await searchClient.Indexers.RunAsync(this.indexName);
return;
}
var parseConfig = new Dictionary <string, object>();
parseConfig.Add("parsingMode", "jsonArray");
var indexerConfig = new Indexer()
{
Name = this.indexName,
DataSourceName = this.dataSourceName,
TargetIndexName = this.indexName,
Parameters = new IndexingParameters()
{
Configuration = parseConfig,
},
};
await searchClient.Indexers.CreateAsync(indexerConfig).ConfigureAwait(false);
}
static void Main(string[] args)
{
string searchServiceName = ConfigurationManager.AppSettings["SearchServiceName"];
string apiKey = ConfigurationManager.AppSettings["SearchServiceApiKey"];
_searchClient = new SearchServiceClient(searchServiceName, new SearchCredentials(apiKey));
_httpClient.DefaultRequestHeaders.Add("api-key", apiKey);
_searchServiceEndpoint = String.Format("https://{0}.{1}", searchServiceName, _searchClient.SearchDnsSuffix);
bool result = RunAsync().GetAwaiter().GetResult();
if (!result && !DebugMode)
{
Console.WriteLine("Something went wrong. Set 'DebugMode' to true in order to see traces.");
}
else if (!result)
{
Console.WriteLine("Something went wrong.");
}
else
{
Console.WriteLine("All operations were successful.");
}
Console.WriteLine("Press any key to exit.");
Console.ReadKey();
}
public AzureQuery(
ISearchIndexClient indexClient, ISearchServiceClient serviceClient,
string category, string[] fields, BooleanOperation op)
: base(category, new StandardAnalyzer(Lucene.Net.Util.Version.LUCENE_29), fields, EmptyOptions, op)
{
IndexClient = indexClient;
ServiceClient = serviceClient;
}
public static async Task <Index> GetNuGetSearchIndexAsync(this ISearchServiceClient client, SearchScorerSettings settings)
{
var index = await client.Indexes.GetAsync(settings.AzureSearchIndexName);
index.EnsureValidNuGetSearchIndex(settings);
return(index);
}
public SearchService(IConfiguration config)
{
_searchClient = new SearchServiceClient(config["Azure:Search:SearchServiceName"],
new SearchCredentials(config["Azure:Search:SearchServiceQueryApiKey"]));
_indexMessagesClient = _searchClient.Indexes.GetClient(config["Azure:Search:SearchServiceMessagesIndexName"]);
_indexConversationsClient = _searchClient.Indexes.GetClient(config["Azure:Search:SearchServiceConversationsIndexName"]);
_indexAzureBlobClient = _searchClient.Indexes.GetClient(config["Azure:Search:SearchServiceAzureblobIndexName"]);
}
public AzSearchService(ISearchServiceClient searchClient, ISearchIndexClient indexClient, ISuggesterBuilder suggesterBuilder, ITolerancePolicy policy, IWeightingBuilder weightingBuilder)
{
this.searchClient = searchClient;
this.indexClient = indexClient;
this.suggesterBuilder = suggesterBuilder;
this.policy = policy;
this.weightingBuilder = weightingBuilder;
}
public SearchRepository(SearchRepositorySettings settings, ISearchInitializer searchInitializer = null, ISearchServiceClient searchServiceClient = null, ISearchIndexClient searchIndexClient = null)
{
_indexName = typeof(T).Name.ToLowerInvariant();
_settings = settings ?? throw new ArgumentNullException(nameof(settings));
_searchInitializer = searchInitializer ?? new SearchInitializer(_settings.SearchServiceName, _settings.SearchKey, null);
_searchServiceClient = searchServiceClient ?? new SearchServiceClient(_settings.SearchServiceName, new SearchCredentials(_settings.SearchKey));
_searchIndexClient = searchIndexClient;
}
public DownloadDataPopulationService(
ISearchServiceClient searchServiceClient,
IPopulationConfiguration populationConfiguration,
IDownloadDataProviderService dowloadDataProviderService)
: base(searchServiceClient, populationConfiguration)
{
_dowloadDataProviderService = dowloadDataProviderService;
}
public async Task RebuildLocationIndex(ISearchServiceClient serviceClient)
{
var indexName = SearchConstants.LocationsIndexName;
await DeleteIndexIfExists(indexName, serviceClient);
await CreateLocationsIndex(serviceClient);
await UploadLocations(serviceClient.Indexes.GetClient(indexName));
}
private async Task CreateCombinedIndex(ISearchServiceClient serviceClient)
{
var indexDefinition = new Index
{
Name = SearchConstants.CombinedIndexName,
Fields = FieldBuilder.BuildForType <CombinedIndexedItem>(),
Analyzers = new List <Analyzer>
{
new CustomAnalyzer
{
Name = SearchConstants.AdvancedAnalyzerName,
TokenFilters = new List <TokenFilterName>
{
TokenFilterName.Lowercase,
TokenFilterName.AsciiFolding,
//TokenFilterName.Phonetic,
//TokenFilterName.EdgeNGram
},
Tokenizer = TokenizerName.Create(SearchConstants.NGramTokenizerName),
//Tokenizer = TokenizerName.EdgeNGram,
},
new CustomAnalyzer
{
Name = SearchConstants.AdvancedAnalyzer_2_Name,
Tokenizer = TokenizerName.EdgeNGram,
TokenFilters = new List <TokenFilterName>
{
TokenFilterName.Lowercase,
"myNGramTokenFilter"
}
}
},
Tokenizers = new List <Tokenizer>
{
new NGramTokenizer(SearchConstants.NGramTokenizerName)
{
MinGram = 4,
MaxGram = 30,
TokenChars = new List <TokenCharacterKind>
{
TokenCharacterKind.Letter,
TokenCharacterKind.Digit,
}
}
},
TokenFilters = new List <TokenFilter>
{
new NGramTokenFilterV2
{
Name = "myNGramTokenFilter",
MinGram = 1,
MaxGram = 100
}
}
};
await serviceClient.Indexes.CreateAsync(indexDefinition);
}
public override void Init(IServiceContainer serviceContainer, IDictionary <string, string> jobArgsDictionary)
{
base.Init(serviceContainer, jobArgsDictionary);
_configuration = _serviceProvider.GetService <PackageLagMonitorConfiguration>();
_catalogClient = _serviceProvider.GetService <ICatalogClient>();
_searchServiceClient = _serviceProvider.GetService <ISearchServiceClient>();
_telemetryService = _serviceProvider.GetService <IPackageLagTelemetryService>();
}
public SearchService(AzureSearchConfiguration configuration)
{
_configuration = configuration;
var azureCredentials = new SearchCredentials(_configuration.ApiKey);
_searchAdminClient = new SearchServiceClient(_configuration.SearchServiceName, azureCredentials);
_searchIndexClient = new SearchIndexClient(_configuration.SearchServiceName, _configuration.IndexName, azureCredentials);
}
public AzureSearch(String serviceName, String apiKey, string indexName)
{
ServiceName = serviceName;
ApiKey = apiKey;
IndexName = indexName;
azureSearchService = new SearchServiceClient(ServiceName, new SearchCredentials(ApiKey));
indexClient = azureSearchService.Indexes.GetClient(IndexName);
}
public SearchServiceClientWrapper(
ISearchServiceClient inner,
DelegatingHandler[] handlers,
RetryPolicy retryPolicy,
ILogger <DocumentsOperationsWrapper> documentsOperationsLogger)
{
_inner = inner ?? throw new ArgumentNullException(nameof(inner));
Indexes = new IndexesOperationsWrapper(_inner.Indexes, handlers, retryPolicy, documentsOperationsLogger);
}
public IndexManager(
ISearchableIndexRepository searchableIndexRepository,
IDateTimeProvider dateTimeProvider,
ISearchServiceClientProvider searchServiceClientProvider)
{
_searchableIndexRepository = searchableIndexRepository;
_dateTimeProvider = dateTimeProvider;
_searchServiceClient = searchServiceClientProvider.Get();
}
/// <summary>
/// Creates Index, Data Source and Indexer for search service.
/// </summary>
/// <returns>task.</returns>
public async Task InitializeSearchServiceDependency()
{
ISearchServiceClient searchClient = this.CreateSearchServiceClient();
await this.CreateSearchIndexAsync(searchClient);
await this.CreateDataSourceAsync(searchClient);
await this.CreateOrRunIndexerAsync(searchClient);
}
static void Main(string[] args)
{
string searchServiceName = "callisto-poc";
string apiKey = "F1B07470817299CF607C8A4A83D055EF";
// Create an HTTP reference to the catalog index
_searchClient = new SearchServiceClient(searchServiceName, new SearchCredentials(apiKey));
_indexClient = _searchClient.Indexes.GetClient(SalesIndexName);
ExecuteQueries();
}
// This Sample shows how to delete, create, upload documents and query an index
static void Main(string[] args)
{
string searchServiceName = ConfigurationManager.AppSettings["SearchServiceName"];
string apiKey = ConfigurationManager.AppSettings["SearchServiceApiKey"];
// Create an HTTP reference to the catalog index
_searchClient = new SearchServiceClient(searchServiceName, new SearchCredentials(apiKey));
_indexClient = _searchClient.Indexes.GetClient(GeoNamesIndex);
Console.WriteLine("{0}", "Deleting index, data source, and indexer...\n");
if (DeleteIndexingResources())
{
Console.WriteLine("{0}", "Creating index...\n");
CreateIndex();
Console.WriteLine("{0}", "Sync documents from Azure SQL...\n");
SyncDataFromAzureSQL();
}
Console.WriteLine("{0}", "Complete. Press any key to end application...\n");
Console.ReadKey();
}
void Init()
{
// References to source and target search services
_legacySearchClient = new SearchServiceClient(Settings.LegacySearchServiceName, new SearchCredentials(Settings.LegacySearchServiceApiKey));
_targetSearchClient = new SearchServiceClient(Settings.TargetSearchServiceName, new SearchCredentials(Settings.TargetSearchServiceApiKey));
}
internal SearchAdministrationService(ISearchServiceClient azureClient)
{
this.AzureClient = azureClient;
this.Indexes = new IndexOperations(this.AzureClient.Indexes);
}
public void CreateOrUpdateSearchIndex(ISearchServiceClient searchServiceClient)
{
var index = CreateSearchIndex();
searchServiceClient.Indexes.CreateOrUpdate(index);
}
static FeaturesSearch()
{
try
{
string searchServiceName = ConfigurationManager.AppSettings["SearchServiceName"];
string apiKey = ConfigurationManager.AppSettings["SearchServiceApiKey"];
// Create an HTTP reference to the catalog index
_searchClient = new SearchServiceClient(searchServiceName, new SearchCredentials(apiKey));
_indexClient = _searchClient.Indexes.GetClient("geonames");
}
catch (Exception e)
{
errorMessage = e.Message.ToString();
}
}
