private static void UploadDocuments(ISearchIndexClient indexClient)
{
var actions = new List <IndexAction <Team> >();
foreach (var team in Teams.GetTeams())
{
Console.WriteLine($"Uploading team {team.TeamName}");
actions.Add(IndexAction.Upload(team));
}
var batch = IndexBatch.New(actions);
try
{
indexClient.Documents.Index(batch);
}
catch (IndexBatchException e)
{
Console.WriteLine(
"Failed to index some of the documents: {0}",
String.Join(", ", e.IndexingResults.Where(r => !r.Succeeded).Select(r => r.Key)));
}
Console.WriteLine("Waiting for indexing...\n");
Thread.Sleep(2000);
}
private static void UploadData()
{
var actions = new IndexAction <Customer>[]
{
IndexAction.Upload(new Customer()
{
customerid = "1", customername = "John", customeremail = "*****@*****.**"
}),
IndexAction.Upload(new Customer()
{
customerid = "2", customername = "Mark", customeremail = "*****@*****.**"
})
};
var batch = IndexBatch.New(actions);
SearchServiceClient serviceClient = new SearchServiceClient(searchServiceName, new SearchCredentials(adminApiKey));
ISearchIndexClient indexClient = serviceClient.Indexes.GetClient("customer");
indexClient.Documents.Index(batch);
Console.WriteLine("Added Data");
Console.ReadKey();
}
public void AddToIndex <T>(IEnumerable <T> documents)
{
var actions = documents.Select(a => IndexAction.Upload(a));
var batch = IndexBatch.New(actions);
searchIndexClient.Documents.Index(batch);
}
private static void ImportDocument(ISearchIndexClient indexClient)
{
var actions = new List <IndexAction <Account> >();
string line = string.Empty;
using (var file = new StreamReader("accounts.json"))
{
while ((line = file.ReadLine()) != null)
{
JObject json = JObject.Parse(line);
Account account = json.ToObject <Account>();
actions.Add(IndexAction.Upload(account));
}
file.Close();
}
var batch = IndexBatch.New(actions);
try
{
indexClient.Documents.Index(batch);
}
catch (Exception)
{
throw;
}
}
public static void UploadDocuments()
{
// This will open the JSON file, parse it and upload the documents in a batch
List <IndexAction> indexOperations = new List <IndexAction>();
JArray json = JArray.Parse(File.ReadAllText(@"contacts.json"));
foreach (var contact in json)
{
//Parse the JSON object (contact)
var doc = new Document();
doc.Add("id", contact["id"]);
doc.Add("name", contact["name"]);
doc.Add("company", contact["company"]);
doc.Add("locationsId", contact["locations"].Select(item => item["id"]).ToList());
doc.Add("locationsDescription", contact["locations"].Select(item => item["description"]).ToList());
doc.Add("locationsCombined", contact["locations"].Select(item => item["id"] + "||" + item["description"]).ToList());
indexOperations.Add(IndexAction.Upload(doc));
}
try
{
indexClient.Documents.Index(new IndexBatch(indexOperations));
}
catch (IndexBatchException e)
{
// Sometimes when your Search service is under load, indexing will fail for some of the documents in
// the batch. Depending on your application, you can take compensating actions like delaying and
// retrying. For this simple demo, we just log the failed document keys and continue.
Console.WriteLine(
"Failed to index some of the documents: {0}",
String.Join(", ", e.IndexingResults.Where(r => !r.Succeeded).Select(r => r.Key)));
}
}
public static void UploadDocuments(ISearchIndexClient indexClient, string fileId, string summary, List <string> keyPhrases)
{
// This is really inefficient as I should be batching the uploads
List <IndexAction> indexOperations = new List <IndexAction>();
var doc = new Document();
doc.Add("fileId", fileId);
doc.Add("summary", summary);
doc.Add("keyPhrases", keyPhrases);
indexOperations.Add(IndexAction.Upload(doc));
try
{
indexClient.Documents.Index(new IndexBatch(indexOperations));
}
catch (IndexBatchException e)
{
// Sometimes when your Search service is under load, indexing will fail for some of the documents in
// the batch. Depending on your application, you can take compensating actions like delaying and
// retrying. For this simple demo, we just log the failed document keys and continue.
Console.WriteLine(
"Failed to index some of the documents: {0}",
String.Join(", ", e.IndexingResults.Where(r => !r.Succeeded).Select(r => r.Key)));
}
}
private static void ImportData(SearchServiceClient serviceClient)
{
List <RentingStats> rentingStats = new List <RentingStats>();
using (var streamReader = new StreamReader(dataFileName))
using (var csvReader = new CsvReader(streamReader))
{
rentingStats = csvReader.GetRecords <RentingStats>().ToList();
}
var actions = new List <IndexAction <RentingStats> >();
foreach (var rentingStat in rentingStats)
{
actions.Add(IndexAction.Upload(rentingStat));
}
var batch = IndexBatch.New(actions);
try
{
ISearchIndexClient indexClient = serviceClient.Indexes.GetClient(indexName);
indexClient.Documents.Index(batch);
}
catch (Exception e)
{
Console.WriteLine(e.ToString());
}
}
public ActionResult Create(Player player)
{
if (string.IsNullOrEmpty(player.Name))
{
log.Error("Player name shouldn't be empty");
throw new ArgumentException("Player name shouldn't be empty");
}
player.Id = Guid.NewGuid();
db.Players.Add(player);
db.SaveChanges();
var actions = new IndexAction <Player>[]
{
IndexAction.Upload(player)
};
var batch = IndexBatch.New(actions);
try
{
_soccerIndex.Documents.Index(batch);
}
catch (IndexBatchException e)
{
// Sometimes when your Search service is under load, indexing will fail for some of the documents in
// the batch. Depending on your application, you can take compensating actions like delaying and
// retrying. For this simple demo, we just log the failed document keys and continue.
Console.WriteLine(
"Failed to index some of the documents: {0}",
String.Join(", ", e.IndexingResults.Where(r => !r.Succeeded).Select(r => r.Key)));
}
return(RedirectToAction("Index"));
}
private void ImportData(ISearchIndexClient indexClient)
{
var actions = new List <IndexAction <Account> >();
string line;
using (System.IO.StreamReader file = new System.IO.StreamReader("accounts.json"))
{
while ((line = file.ReadLine()) != null)
{
JObject json = JObject.Parse(line);
Account account = json.ToObject <Account>();
actions.Add(IndexAction.Upload(account));
}
file.Close();
}
var batch = IndexBatch.New(actions);
try
{
indexClient.Documents.Index(batch);
}
catch (IndexBatchException ex)
{
_logger.Error(ex, ex.Message);
throw ex;
}
}
public static async Task Run([BlobTrigger("properties/{name}", Connection = "StorageConnection")] Stream myBlob, string name, TraceWriter log)
{
var searchServiceName = ConfigurationManager.AppSettings["SearchServiceName"];
var adminApiKey = ConfigurationManager.AppSettings["SearchServiceAdminApiKey"];
var serviceClient = new SearchServiceClient(searchServiceName, new SearchCredentials(adminApiKey));
var blogPost = GetBlogPost(myBlob);
blogPost.filePath = $"{ConfigurationManager.AppSettings["FilePathBeginning"]}{name}";
var action = new[]
{
IndexAction.Upload(blogPost)
};
var batch = IndexBatch.New(action);
var indexClient = serviceClient.Indexes.GetClient(ConfigurationManager.AppSettings["SearchIndexName"]);
try
{
await indexClient.Documents.IndexAsync(batch);
}
catch (IndexBatchException e)
{
log.Error("Error: ", e);
throw;
}
}
public static AzureSearchIndexResult IndexContentBatch(this SearchServiceClient serviceClient, string indexName, IEnumerable <Document> contents)
{
var result = new AzureSearchIndexResult();
var actions = new List <IndexAction>();
foreach (var content in contents)
{
actions.Add(IndexAction.Upload(content));
}
var batch = IndexBatch.New(actions);
var indexClient = serviceClient.Indexes.GetClient(indexName);
try
{
indexClient.Documents.Index(batch);
}
catch (IndexBatchException e)
{
// Sometimes when your Search service is under load, indexing will fail for some of the documents in
// the batch. Depending on your application, you can take compensating actions like delaying and
// retrying. For this simple demo, we just log the failed document keys and continue.
var error =
"Failed to index some of the documents: {0}" + String.Join(", ", e.IndexingResults.Where(r => !r.Succeeded).Select(r => r.Key));
result.Success = false;
result.Message = error;
return(result);
}
result.Success = true;
return(result);
}
public async Task IndexAsync(params string[] packageIds)
{
if (packageIds == null)
{
throw new ArgumentNullException(nameof(packageIds));
}
var actions = new List <IndexAction <PackageDocument> >();
var packageIdSet = new HashSet <string>(packageIds, StringComparer.OrdinalIgnoreCase);
if (packageIdSet.Count > MaxBatchSize)
{
throw new ArgumentException($"Cannot index more than {MaxBatchSize} packages at once");
}
_logger.LogInformation("Indexing {PackageCount} packages...", packageIdSet.Count);
foreach (var packageId in packageIdSet)
{
foreach (var document in await BuildDocumentsAsync(packageId))
{
actions.Add(IndexAction.Upload(document));
}
}
var batch = IndexBatch.New(actions);
// TODO: Add retry on IndexBatchException
// See: https://docs.microsoft.com/en-us/azure/search/search-import-data-dotnet#import-data-to-the-index
await _indexClient.Documents.IndexAsync(batch);
_logger.LogInformation("Indexed {PackageCount} packages", packageIdSet.Count);
}
private async Task ImportDataAsync()
{
var data = await File.ReadAllLinesAsync(options.HotelFileName).ConfigureAwait(false);
var hotels = data.Skip(1).Select(r =>
{
var columns = r.Split("\t");
return(new Hotel
{
HotelId = columns[0],
HotelName = columns[1],
Description = columns[2],
DescriptionFr = columns[3],
Category = columns[4],
Tags = columns[5].Split(",").ToImmutableArray(),
ParkingIncluded = columns[6] == "0" ? false : true,
SmokingAllowed = columns[7] == "0" ? false : true,
LastRenovationDate = Convert.ToDateTime(columns[8], CultureInfo.InvariantCulture),
BaseRate = Convert.ToDouble(columns[9], CultureInfo.InvariantCulture),
Rating = Convert.ToInt32(Convert.ToDouble(columns[10], CultureInfo.InvariantCulture))
});
}).ToList();
var actions = hotels.Select(h => IndexAction.Upload(h)).ToList();
var batch = IndexBatch.New(actions);
using (var client = CreateSearchServiceClient())
{
await client.Indexes.GetClient(options.IndexName).Documents.IndexAsync(batch).ConfigureAwait(false);
}
logger.LogInformation("Imported {@Count} hotels", hotels.Count);
}
private static async Task WriteToSiAsync(IEnumerable <Book> listBook)
{
SearchServiceClient serviceClient = new SearchServiceClient("librarysearchservice", new SearchCredentials("<api-key>"));
var indexClient = serviceClient.Indexes.GetClient("booksindex");
var act = listBook.Select(x => IndexAction.Upload <Book>(x));
await indexClient.Documents.IndexAsync(IndexBatch.New(act));
}
private void ImportDocuments(ISearchIndexClient indexClient)
{
var actions = new IndexAction <RealState>[]
{
IndexAction.Upload(
new RealState()
{
ListingId = "1",
Name = "Madrid",
Beds = 2,
Baths = "1",
Description = "Meilleur hôtel en ville",
Status = "Available",
Type = "House",
City = "Bern",
Price = 1200
}),
IndexAction.Upload(
new RealState()
{
ListingId = "2",
Name = "Real",
Beds = 3,
Baths = "2",
Description = "Hôtel le moins cher en ville",
Status = "Hired",
Type = "Room",
City = "Madrid",
Price = 1600
}),
IndexAction.MergeOrUpload(
new RealState()
{
ListingId = "3",
Name = "Empire",
Beds = 3,
Baths = "2",
Description = "Mansion Le Blank",
Status = "Sold",
Type = "Castle",
City = "London",
Price = 1000
}),
//IndexAction.Delete(new RealState() { ListingId = "6" })
};
var batch = IndexBatch.New(actions);
try
{
indexClient.Documents.Index(batch);
}
catch (IndexBatchException e)
{
Console.WriteLine("Failed to index some of the documents: {0}", String.Join(", ", e.IndexingResults.Where(r => !r.Succeeded).Select(r => r.Key)));
}
Console.WriteLine("Waiting for documents to be indexed...\n");
Thread.Sleep(2000);
}
private static void UploadDoc(Cliente data, ISearchIndexClient indexClient)
{
//Criando o documento a ser indexado
var actions = new IndexAction <Cliente>[] { IndexAction.Upload(data) };
var batch = IndexBatch.New(actions);
//Atualizado o indice com o novo documento
indexClient.Documents.Index(batch);
}
public async Task CreateAsync <T>(T item, IGraphRequestContext graphRequestContext) where T : class
{
var client = Get <T>(graphRequestContext);
var idx = IndexAction.Upload(item);
await client.Documents.IndexAsync(new IndexBatch <T>(
new List <IndexAction <T> > {
idx
}));
}
public async Task DoesNotEnqueueChangesForNoIndexActions()
{
_config.AzureSearchBatchSize = 2;
_producer
.Setup(x => x.ProduceWorkAsync(It.IsAny <ConcurrentBag <NewPackageRegistration> >(), It.IsAny <CancellationToken>()))
.ReturnsAsync(() => _initialAuxiliaryData)
.Callback <ConcurrentBag <NewPackageRegistration>, CancellationToken>((w, _) =>
{
w.Add(new NewPackageRegistration("A", 0, new[] { "Microsoft", "EntityFramework" }, new Package[0], false));
w.Add(new NewPackageRegistration("B", 0, new[] { "nuget" }, new Package[0], false));
w.Add(new NewPackageRegistration("C", 0, new[] { "aspnet" }, new Package[0], false));
});
// Return empty index action for ID "B". This package ID will not be pushed to Azure Search but will appear
// in the initial owners data file.
_builder
.Setup(x => x.AddNewPackageRegistration(It.Is <NewPackageRegistration>(y => y.PackageId != "B")))
.Returns <NewPackageRegistration>(x => new IndexActions(
new List <IndexAction <KeyedDocument> > {
IndexAction.Upload(new KeyedDocument {
Key = x.PackageId
})
},
new List <IndexAction <KeyedDocument> >(),
new ResultAndAccessCondition <VersionListData>(
new VersionListData(new Dictionary <string, VersionPropertiesData>()),
AccessConditionWrapper.GenerateEmptyCondition())));
_builder
.Setup(x => x.AddNewPackageRegistration(It.Is <NewPackageRegistration>(y => y.PackageId == "B")))
.Returns <NewPackageRegistration>(x => new IndexActions(
new List <IndexAction <KeyedDocument> >(),
new List <IndexAction <KeyedDocument> >(),
new ResultAndAccessCondition <VersionListData>(
new VersionListData(new Dictionary <string, VersionPropertiesData>()),
AccessConditionWrapper.GenerateEmptyCondition())));
var enqueuedIndexActions = new List <KeyValuePair <string, IndexActions> >();
_batchPusher
.Setup(x => x.EnqueueIndexActions(It.IsAny <string>(), It.IsAny <IndexActions>()))
.Callback <string, IndexActions>((id, actions) =>
{
enqueuedIndexActions.Add(KeyValuePair.Create(id, actions));
});
await _target.ExecuteAsync();
Assert.Equal(2, enqueuedIndexActions.Count);
var keys = enqueuedIndexActions
.Select(x => x.Key)
.OrderBy(x => x)
.ToArray();
Assert.Equal(
new[] { "A", "C" },
keys);
}
public async Task Add(SearchEntityModel document)
{
var batch = IndexBatch.New(new IndexAction <SearchEntityModel>[] {
IndexAction.Upload(document)
});
await _indexClient.Documents.IndexAsync(batch);
}
private static async Task LoadDocumentsAsync(
ISearchIndexClient indexClient,
Post[] posts)
{
var actions = from p in posts
select IndexAction.Upload(p);
var batch = IndexBatch.New(actions);
var result = await indexClient.Documents.IndexAsync(batch);
}
public void DoIndex(ISearchService searchService, ISettingsManager settingsManager, IPostService postService,
IConfig config, ITopicService topicService, IErrorLog errorLog)
{
var topic = searchService.GetNextTopicForIndexing();
if (topic != null)
{
var serviceClient = new SearchServiceClient(config.SearchUrl, new SearchCredentials(config.SearchKey));
if (!serviceClient.Indexes.Exists(IndexName))
{
CreateIndex(serviceClient);
}
var posts = postService.GetPosts(topic, false).ToArray();
var parsedPosts = posts.Select(x =>
{
var parsedText = _textParsingService.ClientHtmlToForumCode(x.FullText);
parsedText = _textParsingService.RemoveForumCode(parsedText);
return(parsedText);
}).ToArray();
var searchTopic = new SearchTopic
{
TopicID = topic.TopicID.ToString(),
ForumID = topic.ForumID,
Title = topic.Title,
LastPostTime = topic.LastPostTime,
StartedByName = topic.StartedByName,
Replies = topic.ReplyCount,
Views = topic.ViewCount,
IsClosed = topic.IsClosed,
IsPinned = topic.IsPinned,
UrlName = topic.UrlName,
LastPostName = topic.LastPostName,
Posts = parsedPosts
};
var actions =
new IndexAction <SearchTopic>[]
{
IndexAction.Upload(searchTopic)
};
try
{
var serviceIndexClient = serviceClient.Indexes.GetClient(IndexName);
var batch = IndexBatch.New(actions);
serviceIndexClient.Documents.Index(batch);
searchService.MarkTopicAsIndexed(topic);
}
catch (Exception exc)
{
errorLog.Log(exc, ErrorSeverity.Error);
topicService.MarkTopicForIndexing(topic.TopicID);
}
}
}
public void DoIndex(int topicID, string tenantID)
{
var topic = _topicService.Get(topicID);
if (topic != null)
{
var serviceClient = new SearchServiceClient(_config.SearchUrl, new SearchCredentials(_config.SearchKey));
if (!serviceClient.Indexes.Exists(IndexName))
{
CreateIndex(serviceClient);
}
var posts = _postService.GetPosts(topic, false).ToArray();
var parsedPosts = posts.Select(x =>
{
var parsedText = _textParsingService.ClientHtmlToForumCode(x.FullText);
parsedText = _textParsingService.RemoveForumCode(parsedText);
return(parsedText);
}).ToArray();
var searchTopic = new SearchTopic
{
TopicID = topic.TopicID.ToString(),
ForumID = topic.ForumID,
Title = topic.Title,
LastPostTime = topic.LastPostTime,
StartedByName = topic.StartedByName,
Replies = topic.ReplyCount,
Views = topic.ViewCount,
IsClosed = topic.IsClosed,
IsPinned = topic.IsPinned,
UrlName = topic.UrlName,
LastPostName = topic.LastPostName,
Posts = parsedPosts,
TenantID = tenantID
};
var actions =
new[]
{
IndexAction.Upload(searchTopic)
};
try
{
var serviceIndexClient = serviceClient.Indexes.GetClient(IndexName);
var batch = IndexBatch.New(actions);
serviceIndexClient.Documents.Index(batch);
}
catch (Exception exc)
{
_errorLog.Log(exc, ErrorSeverity.Error);
_topicService.QueueTopicForIndexing(topic.TopicID);
}
}
}
private static void UploadDoc(List <Cliente> data, ISearchIndexClient indexClient)
{
//Criando o documento a ser indexado
var actions = new List <IndexAction <Cliente> >();
data.ForEach(d => actions.Add(IndexAction.Upload(d)));
var batch = IndexBatch.New(actions);
//Atualizando o indice com o novo documento
indexClient.Documents.Index(batch);
}
private IndexBatch <T> UploadIndexBatch <T>(IEnumerable <T> data) where T : class
{
var indexAtions = new List <IndexAction <T> >();
foreach (var item in data)
{
indexAtions.Add(IndexAction.Upload(item));
}
return(IndexBatch.New(indexAtions));
}
private static IndexAction <IndexablePub> BuildIndexablePub(Pub pub)
{
try
{
return(IndexAction.Upload(new IndexablePub(pub)));
}
catch (Exception exception)
{
Console.Out.WriteLine($"Failed to convert: {pub.Name} - Error: {exception}");
return(null);
}
}
public async Task PushesToIndexesUsingMaximumBatchSize()
{
_config.AzureSearchBatchSize = 2;
_producer
.Setup(x => x.ProduceWorkAsync(It.IsAny <ConcurrentBag <NewPackageRegistration> >(), It.IsAny <CancellationToken>()))
.ReturnsAsync(() => _initialAuxiliaryData)
.Callback <ConcurrentBag <NewPackageRegistration>, CancellationToken>((w, _) =>
{
w.Add(new NewPackageRegistration("A", 0, new string[0], new Package[0], false));
w.Add(new NewPackageRegistration("B", 0, new string[0], new Package[0], false));
w.Add(new NewPackageRegistration("C", 0, new string[0], new Package[0], false));
w.Add(new NewPackageRegistration("D", 0, new string[0], new Package[0], false));
w.Add(new NewPackageRegistration("E", 0, new string[0], new Package[0], false));
});
_builder
.Setup(x => x.AddNewPackageRegistration(It.IsAny <NewPackageRegistration>()))
.Returns <NewPackageRegistration>(x => new IndexActions(
new List <IndexAction <KeyedDocument> > {
IndexAction.Upload(new KeyedDocument {
Key = x.PackageId
})
},
new List <IndexAction <KeyedDocument> >(),
new ResultAndAccessCondition <VersionListData>(
new VersionListData(new Dictionary <string, VersionPropertiesData>()),
AccessConditionWrapper.GenerateEmptyCondition())));
var enqueuedIndexActions = new List <KeyValuePair <string, IndexActions> >();
_batchPusher
.Setup(x => x.EnqueueIndexActions(It.IsAny <string>(), It.IsAny <IndexActions>()))
.Callback <string, IndexActions>((id, actions) =>
{
enqueuedIndexActions.Add(KeyValuePair.Create(id, actions));
});
await _target.ExecuteAsync();
Assert.Equal(5, enqueuedIndexActions.Count);
var keys = enqueuedIndexActions
.Select(x => x.Key)
.OrderBy(x => x)
.ToArray();
Assert.Equal(
new[] { "A", "B", "C", "D", "E" },
keys);
_batchPusher.Verify(x => x.TryPushFullBatchesAsync(), Times.Exactly(5));
_batchPusher.Verify(x => x.TryFinishAsync(), Times.Once);
}
/// <summary>
/// Upload document to Azure search service
/// </summary>
public static async Task UploadDocumentToSearchService <TDocument>(string indexName, TDocument document)
where TDocument : SearchDocument
{
ISearchIndexClient searchIndexClient = SearchService.Indexes.GetClient(indexName);
IndexAction <TDocument>[] actions = new IndexAction <TDocument>[]
{
IndexAction.Upload(document)
};
IndexBatch <TDocument> batch = IndexBatch.New(actions);
await searchIndexClient.Documents.IndexAsync(batch);
}
protected override async Task ProcessMessage(ProductCreated product, string messageId, Message.SystemPropertiesCollection systemProperties, IDictionary <string, object> userProperties, CancellationToken cancellationToken)
{
var serviceName = this._configuration["AzureSearchIndex:ServiceName"];
var serviceKey = this._configuration["AzureSearchIndex:ServiceAdminKey"];
var indexName = this._configuration["AzureSearchIndex:CatalogIndex"];
var serviceClient = new SearchServiceClient(serviceName, new SearchCredentials(serviceKey));
var indexClient = serviceClient.Indexes.GetClient(indexName);
var actions = new IndexAction <CatalogDataIndex>[]
{
IndexAction.Upload(
new CatalogDataIndex
{
Id = product.ProductId.ToString(),
Name = product.Name,
Description = product.Description,
Brand = product.BrandId,
BrandName = product.BrandName,
Price = Convert.ToDouble(product.BasePrice),
SpecialPrice = Convert.ToDouble(product.SpecialPrice),
Stock = product.Stock,
Store = product.SellerId,
StoreName = product.SellerName,
}
),
};
var batch = IndexBatch.New(actions);
try
{
await indexClient.Documents.IndexAsync(batch);
}
catch (IndexBatchException e)
{
// When a service is under load, indexing might fail for some documents in the batch.
// Depending on your application, you can compensate by delaying and retrying.
// For this simple demo, we just log the failed document keys and continue.
this._logger.LogError(
"Failed to index some of the documents: {0}",
String.Join(", ", e.IndexingResults.Where(r => !r.Succeeded).Select(r => r.Key)));
}
catch (Exception e)
{
this._logger.LogError(e.ToString());
}
}
private static void IndexDocuments(string indexName, List <string> groups)
{
var actions = new IndexAction <SecuredFiles>[]
{
IndexAction.Upload(
new SecuredFiles()
{
FileId = "1",
Name = "secured_file_a",
GroupIds = new[] { groups[0] }
}),
IndexAction.Upload(
new SecuredFiles()
{
FileId = "2",
Name = "secured_file_b",
GroupIds = new[] { groups[0] }
}),
IndexAction.Upload(
new SecuredFiles()
{
FileId = "3",
Name = "secured_file_c",
GroupIds = new[] { groups[1] }
})
};
var batch = IndexBatch.New(actions);
try
{
_indexClient.Documents.Index(batch);
}
catch (IndexBatchException e)
{
// Sometimes when your Search service is under load, indexing will fail for some of the documents in
// the batch. Depending on your application, you can take compensating actions like delaying and
// retrying. For this simple demo, we just log the failed document keys and continue.
Console.WriteLine(
"Failed to index some of the documents: {0}",
String.Join(", ", e.IndexingResults.Where(r => !r.Succeeded).Select(r => r.Key)));
}
Console.WriteLine("Waiting for documents to be indexed...\n");
Thread.Sleep(2000);
}
private static void ImportData(SearchServiceClient serviceClient)
{
var hotelsText = File.ReadAllLines(hotelFileName);
var hotels = new List <Hotel>();
for (int i = 1; i < hotelsText.Length; i++)
{
var hotelText = hotelsText[i];
var hotelTextColumns = hotelText.Split("\t");
hotels.Add(
new Hotel()
{
HotelId = hotelTextColumns[0],
HotelName = hotelTextColumns[1],
Description = hotelTextColumns[2],
DescriptionFr = hotelTextColumns[3],
Category = hotelTextColumns[4],
Tags = hotelTextColumns[5].Split(","),
ParkingIncluded = hotelTextColumns[6] == "0" ? false : true,
SmokingAllowed = hotelTextColumns[7] == "0" ? false : true,
LastRenovationDate = Convert.ToDateTime(hotelTextColumns[8]),
BaseRate = Convert.ToDouble(hotelTextColumns[9]),
Rating = (int)Convert.ToDouble(hotelTextColumns[10])
});
} // no error checking because demo code
var actions = new List <IndexAction <Hotel> >();
foreach (var hotel in hotels)
{
actions.Add(IndexAction.Upload(hotel));
}
var batch = IndexBatch.New(actions);
try
{
ISearchIndexClient indexClient = serviceClient.Indexes.GetClient("hotels");
indexClient.Documents.Index(batch);
}
catch (Exception e)
{
Console.WriteLine(e.ToString());
}
}