public GameDataManager()
{
try
{
var elasticSearchUrl = ConfigurationManager.AppSettings["ElasticStoreConnection"];
var index = ConfigurationManager.AppSettings["EIndex_Game"];
_settings =
new ConnectionSettings(new Uri(elasticSearchUrl)).SetDefaultIndex(index).PluralizeTypeNames();
_client = new ElasticClient(_settings);
var isIndexExist = _client.IndexExists(i => i.Index(index));
if (!isIndexExist.Exists)
{
_client.CreateIndex(c => c.Index(index));
_settings.SetDefaultIndex(index);
_client = new ElasticClient(_settings);
}
var response =
_client.Map<Game>(
h =>
h.Properties(p => p
.String(s => s.Name(i => i.GameId).Index(FieldIndexOption.NotAnalyzed))
.String(s => s.Name(i => i.Status).Index(FieldIndexOption.NotAnalyzed))
.String(s => s.Name(i => i.TurnOfPlayer).Index(FieldIndexOption.NotAnalyzed))
.Object<Winner>(o => o.Name(w => w.Winner).Properties(wp => wp.String(f => f.Name(l => l.FacebookId).Index(FieldIndexOption.NotAnalyzed)))
)));
IsServerError(response);
}
catch (Exception ex)
{
Logger.LogException(ex, _source, "GameDataManager", Severity.Critical);
throw;
}
}
public void RebuildIndex(string userId, int? noteId)
{
if (!string.IsNullOrWhiteSpace(userId))
{
var notes = new List<NoteModel>();
if (noteId.HasValue)
notes.Add(Repository.GetById(noteId.Value));
else
notes = Repository.GetByUserId(userId).ToList();
var settings = new ConnectionSettings(new Uri("http://localhost:9200"), "mapnotes");
var client = new ElasticClient(settings);
var indexExists = client.IndexExists("mapnotes");
if (!indexExists.Exists)
{
client.CreateIndex(descriptor => descriptor.Index("mapnotes")
.AddMapping<NoteIndex>(m => m.Properties(p => p.GeoPoint(d => d.Name(f => f.Location).IndexLatLon()))));
}
foreach (var note in notes)
{
client.Index(new NoteIndex
{
Id = note.Id,
UserId = note.UserId,
Title = note.Title,
Location = new Location(note.Latitude, note.Longitude)
});
}
}
}
public BlackListDataManager()
{
try
{
var elasticSearchUrl = ConfigurationManager.AppSettings["ElasticStoreConnection"];
var index = ConfigurationManager.AppSettings["EIndex_BlackList"];
_settings =
new ConnectionSettings(new Uri(elasticSearchUrl)).SetDefaultIndex(index).PluralizeTypeNames();
_client = new ElasticClient(_settings);
var isIndexExist = _client.IndexExists(i => i.Index(index));
if (!isIndexExist.Exists)
{
_client.CreateIndex(c => c.Index(index));
_settings.SetDefaultIndex(index);
_client = new ElasticClient(_settings);
}
var response =
_client.Map<BlockedUser>(
h =>
h.MapFromAttributes(10).Properties(p => p
.String(s => s.Name(i => i.ByEmail).Index(FieldIndexOption.NotAnalyzed))
.String(s => s.Name(i => i.ToEmail).Index(FieldIndexOption.NotAnalyzed))
));
IsServerError(response);
}
catch (Exception ex)
{
Logger.LogException(ex, _soruce, "BlackListDataManager", Severity.Critical);
throw;
}
}
public IResponse Execute()
{
// create client connection
var node = new Uri(ServerUrl);
var conn = new ConnectionSettings(node, this.IndexName);
var client = new ElasticClient(conn);
// check index name existance
var existenceResult = client.GetIndex(i => i.Index(IndexName));
if (existenceResult.ConnectionStatus.Success)
{
// delete exist index
var deleteResult = client.DeleteIndex(i => i.Index(IndexName));
if (!deleteResult.Acknowledged)
return deleteResult;
}
// create index
var createResult = client.CreateIndex(i => i.Index(IndexName));
if (!createResult.Acknowledged)
return createResult;
// set analyzer
SetAnalyzers(client);
// put mapping
var putResult = client.Map<TranslationMemory>(m => m.Index(this.IndexName).MapFromAttributes());
//var putResult = client.Map<ElasticSearchProject>(m => m.Index(this.IndexName));
return putResult;
}
public static void Setup()
{
var client = new ElasticClient(ElasticsearchConfiguration.Settings(hostOverride: new Uri("http://localhost:9200")));
//uncomment the next line if you want to see the setup in fiddler too
//var client = ElasticsearchConfiguration.Client;
var projects = NestTestData.Data;
var people = NestTestData.People;
var boolTerms = NestTestData.BoolTerms;
var createIndexResult = client.CreateIndex(ElasticsearchConfiguration.DefaultIndex, c => c
.NumberOfReplicas(0)
.NumberOfShards(1)
.AddMapping<ElasticsearchProject>(m => m
.MapFromAttributes()
.Properties(p => p
.String(s => s.Name(ep => ep.Content).TermVector(TermVectorOption.with_positions_offsets_payloads))))
.AddMapping<Person>(m => m.MapFromAttributes())
.AddMapping<BoolTerm>(m => m.Properties(pp=>pp
.String(sm => sm.Name(p => p.Name1).Index(FieldIndexOption.not_analyzed))
.String(sm => sm.Name(p => p.Name2).Index(FieldIndexOption.not_analyzed))
))
);
var createAntotherIndexResult = client.CreateIndex(ElasticsearchConfiguration.DefaultIndex + "_clone", c => c
.NumberOfReplicas(0)
.NumberOfShards(1)
.AddMapping<ElasticsearchProject>(m => m
.MapFromAttributes()
.Properties(p => p
.String(s => s.Name(ep => ep.Content).TermVector(TermVectorOption.with_positions_offsets_payloads))))
.AddMapping<Person>(m => m.MapFromAttributes())
.AddMapping<BoolTerm>(m => m.Properties(pp => pp
.String(sm => sm.Name(p => p.Name1).Index(FieldIndexOption.not_analyzed))
.String(sm => sm.Name(p => p.Name2).Index(FieldIndexOption.not_analyzed))
))
);
var bulkResponse = client.Bulk(b=>b
.IndexMany(projects)
.IndexMany(people)
.IndexMany(boolTerms)
.Refresh()
);
}
static void Main(string[] args)
{
elasticSettings = new ConnectionSettings(new Uri("http://127.0.0.1:9200"))
.SetDefaultIndex("people");
client = new ElasticClient(elasticSettings);
client.DeleteIndex("people");
// Create an index
client.CreateIndex("people", c => c
.NumberOfReplicas(0)
.NumberOfShards(1));
client.MapFluent<Person>(m => m.IndexAnalyzer("standard")
.Properties(props => props
.String(s => s
.Name(p => p.Message)
.Index(FieldIndexOption.analyzed))
.Number(n => n
.Name(p => p.Age))
.String(s => s
.Name(p => p.FirstName))
.String(s => s
.Name(p => p.Sex))
.String(s => s
.Name(p => p.LastName))));
//Add some people
var jp = new Person { FirstName = "JP", LastName = "Smith", Age = 37, Message = "OMG yay ES!", Sex = "Male" };
var matt = new Person { FirstName = "Matt", LastName = "Toto", Age = 32, Message = "I'm JPs brother", Sex = "Male" };
var christine = new Person { FirstName = "Christine", LastName = "Toto", Age = 0, Message = "I'm JPs wife", Sex = "Female" };
var kevin = new Person { FirstName = "Kevin", LastName = "Toto", Age = 26, Message = "I'm JPs other brother", Sex = "Male" };
client.Index(jp);
client.Index(matt);
client.Index(christine);
client.Index(kevin);
client.Refresh();
///// ** Wildcard search
var searchResults = client.Search<Person>(s => s
.From(0)
.Size(10)
.Query(q => q
.Wildcard(f => f.LastName, "to*", Boost: 1.0)
)
);
foreach (var result in searchResults.Documents)
{
Console.WriteLine("Found: {0}", result.FirstName + " " + result.LastName);
}
Console.ReadKey();
}
/// <summary>
/// 创建索引
/// </summary>
public void CreateIndex()
{
string espath = ConfigurationManager.AppSettings["ESPath"].ToString();
string indexname = ConfigurationManager.AppSettings["IndexName"].ToString();
string typename = ConfigurationManager.AppSettings["TypeName"].ToString();
var node = new Uri(espath);
var settings = new ConnectionSettings(node);
var client = new ElasticClient(settings);
var newbase = new NewsBase();
client.CreateIndex(indexname);
client.Map<NewsBase>(m => m.MapFromAttributes());
}
public ElasticsearchClient()
{
this.connexion = new Uri("http://10.188.197.209:9200");
//this.connexion = new Uri("http://localhost:9200");
// this.connexion = new Uri("http://192.168.1.14:9200");
this.connexion = new Uri("http://localhost:9200");
this.settings = new ConnectionSettings(connexion, defaultIndex: "tp");
this.client = new ElasticClient(settings);
client.CreateIndex("tp");
var mapResult = client.Map<Stockobject>(c => c.MapFromAttributes().IgnoreConflicts().Type("stocks").Indices("tp"));
}
public static void CreateIndex(string elasticSearchConnectionString, string index, int shards, int replicas)
{
CreateIndexRequest req = new CreateIndexRequest(index);
req.Settings = new IndexSettings
{
NumberOfReplicas = replicas,
NumberOfShards = shards
};
var client = new Nest.ElasticClient(new Uri(elasticSearchConnectionString));
var res = client.CreateIndex(req);
}
//static constructor to ensure config settings are set
static ElasticSearchConnection()
{
DropShareServerName = DataMartAppSettings.Default.dropshareServerName;
DropShare = DataMartAppSettings.Default.dropshareFolderName;
ElasticSearchUrl = DataMartAppSettings.Default.elasticSearchURL;
ConnectionSettings conSettings = new ConnectionSettings(new Uri(ElasticSearchUrl));
ESClient = new ElasticClient(conSettings);
//Create the logging index in the Server if it doesn't already exists
if (!ESClient.IndexExists("logs").Exists)
{
ESClient.CreateIndex("logs");
}
}
public static ElasticClient Create()
{
var esHost = ConfigurationManager.AppSettings["esHost"];
Log.DebugFormat("esHost = {0}", esHost);
var esIndex = ConfigurationManager.AppSettings["esIndex"];
Log.DebugFormat("esIndex = {0}", esIndex);
var client = new ElasticClient(new ConnectionSettings(new Uri(esHost)).SetDefaultIndex(esIndex));
//TODO: double-check
lock (Locker)
{
if (!client.IndexExists(esIndex).Exists)
client.CreateIndex(esIndex, new IndexSettings());
}
return client;
}
public static void TestPage_Type_Mapping_Should_Create_Index_And_Return_IsValid()
{
var elasticClient = new ElasticClient(new Uri("http://localhost:9200"));
var helper = new TypeScanIndexableTypeMapperResolver();
var indexableTypeMappers = helper.GetAll().ToList();
var typeMapper = indexableTypeMappers.First();
var typeMapping = typeMapper.CreateTypeMapping(new CultureInfo("en"));
var typeName = typeMapper.TypeName;
var mappingsDescriptor = new MappingsDescriptor();
mappingsDescriptor.Map<IIndexablePageData>(typeName, x => typeMapping);
var createIndexResponse = elasticClient.CreateIndex("site_en_1", x => x.Mappings(m => mappingsDescriptor));
Assert.Equal(true, createIndexResponse.IsValid);
Assert.Equal(true, createIndexResponse.Acknowledged);
}
static void Main(string[] args)
{
elasticSettings = new ConnectionSettings(new Uri("http://127.0.0.1:9200"))
.SetDefaultIndex("people");
client = new ElasticClient(elasticSettings);
client.DeleteIndex("people");
// Create an index
client.CreateIndex("people", c => c
.NumberOfReplicas(0)
.NumberOfShards(1)
.AddMapping<Person>(m => m.MapFromAttributes()));
// Add some people
var jp = new Person { FirstName = "JP", LastName = "Toto", Age = 37, Message = "OMG yay ES!", Sex = "Male" };
var matt = new Person { FirstName = "Matt", LastName = "Toto", Age = 32, Message = "I'm JPs brother", Sex = "Male" };
var christine = new Person { FirstName = "Christine", LastName = "Toto", Age = 0, Message = "I'm JPs wife", Sex = "Female" };
var kevin = new Person { FirstName = "Kevin", LastName = "Toto", Age = 26, Message = "I'm JPs other brother", Sex = "Male" };
client.Index(jp);
client.Index(matt);
client.Index(christine);
client.Index(kevin);
client.Refresh();
var searchResults = client.Search<Person>(s => s
.From(0)
.Size(10)
.Fields(f => f.FirstName, f => f.LastName)
.Query(q => q
.MatchPhrase(j => j.OnField("Message").QueryString("i'm jps brother"))
)
);
foreach (var result in searchResults.Documents)
{
Console.WriteLine("Found: {0}", result.FirstName + " " + result.LastName);
}
Console.ReadKey();
}
public void ConfigureElasticClient()
{
//var setting = new ConnectionSettings(new Uri("http://localhost:9200/"),Constants.INDEX_PERSON);
//setting.EnableTrace();
//setting.ExposeRawResponse();
//client = new ElasticClient(setting);
var node = new Uri(Constants.ELASTIC_SEARCH_URI);
var settings = new ConnectionSettings(node);
settings.SetDefaultIndex(Constants.INDEX_PERSON);
settings.MapDefaultTypeNames(m => m.Add(typeof(Person), (Constants.INDEX_PERSON)));
client = new ElasticClient(settings);
client.CreateIndex(ci => ci
.Index(Constants.INDEX_PERSON)
.AddMapping<Person>(m => m.MapFromAttributes()));
}
public void CreatePersonWithImageAttachment()
{
var node = new Uri("http://localhost:9200");
var settings = new ConnectionSettings(
node,
defaultIndex: "my-application"
);
var client = new ElasticClient(settings);
//client.DeleteIndex("index-name");
client.CreateIndex("index-name", c => c
.AddMapping<Document>(m => m.MapFromAttributes())
);
string path = "c:\\test.png";
var attachment = new Attachment
{
Content = Convert.ToBase64String(File.ReadAllBytes(path)),
ContentType = "image/jpeg",
Name = "IMG_9896.JPG"
};
var person = new Person
{
Id = Convert.ToString(new Random(DateTime.Now.Second).Next(20000)),
Firstname = "Martijn",
Lastname = "Laarman",
File = new[] { attachment }
};
var index = client.Index(person);
var results = client.Search<Person>(s => s
.From(0)
.Size(10)
.Query(q => q
.Term(p => p.Firstname, "martijn")
)
);
}
private static void CreateIndex(string name, ElasticClient client)
{
if (client.IndexExists(x => x.Index(name)).Exists)
{
Log.Logger.Information("Delete index {indexName}", name);
client.DeleteIndex(x => x.Index(name));
}
Log.Logger.Information("Create index {indexName}", name);
client.CreateIndex(name, c => c
.NumberOfReplicas(0)
.NumberOfShards(1)
.AddMapping<Book>(m => m.MapFromAttributes())
.AddMapping<CD>(m => m.MapFromAttributes()));
Log.Logger.Information("Index {indexName} created", name);
Log.Logger.Information("Closing index {indexName}", name);
Thread.Sleep(30000);
var closeRes = client.CloseIndex(x => x.Index(name));
if (!closeRes.Acknowledged)
Log.Logger.Error("Could not close index: {message}",closeRes.ServerError.Error);
Log.Logger.Information("Add analyzer to index {indexName}", name);
var res = client.Raw.IndicesPutSettings(name, File.ReadAllText("Analyzer.json"));
if (!res.Success)
Log.Logger.Error("Could not create analyzer: {error}", res.OriginalException.ToString());
Log.Logger.Information("Open index {indexName}", name);
client.OpenIndex(x => x.Index(name));
RandomBooks(1000, name, client);
RandomCDs(1000, name, client);
}
public HttpResponseMessage CreateIndex(FormDataCollection postData)
{
SampleConfiguration config = new SampleConfiguration();
esNode = new Uri(config.ElasticsearchServerHost);
string indexName = postData.Get("indexName");
connectionSettings = new ConnectionSettings(esNode, defaultIndex: indexName);
var indexSettings = new IndexSettings();
indexSettings.NumberOfShards = 1;
indexSettings.NumberOfReplicas = 0;
esClient = new ElasticClient(connectionSettings);
IIndicesOperationResponse indexOperationResponse = esClient.CreateIndex(c => c
.Index(indexName)
.InitializeUsing(indexSettings)
.AddMapping<Product>(m => m.MapFromAttributes())
);
if (indexOperationResponse.Acknowledged == true)
return Request.CreateResponse(HttpStatusCode.Created, indexOperationResponse.Acknowledged);
else
return Request.CreateResponse(HttpStatusCode.InternalServerError, indexOperationResponse.Acknowledged);
}
static void Main(string[] args)
{
elasticSettings = new ConnectionSettings(new Uri("http://127.0.0.1:9200"))
.SetDefaultIndex("people");
client = new ElasticClient(elasticSettings);
// Create an index
client.CreateIndex("people", c => c
.NumberOfReplicas(0)
.NumberOfShards(4)
.AddMapping<Person>(m => m.MapFromAttributes()));
// Add some people
var jp = new Person {FirstName = "JP", LastName = "Smith", Age = 37, Message = "OMG yay ES!", Sex = "Male"};
var matt = new Person { FirstName = "Matt", LastName = "Toto", Age = 32, Message = "I'm JPs brother", Sex = "Male" };
var christine = new Person { FirstName = "Christine", LastName = "Toto", Age = 0, Message = "I'm JPs wife", Sex = "Female" };
var kevin = new Person { FirstName = "Kevin", LastName = "Toto", Age = 26, Message = "I'm JPs other brother", Sex = "Male" };
client.Index(jp);
client.Index(matt);
client.Index(christine);
client.Index(kevin);
}
static void Main(string[] args)
{
var reader = new StreamReader("C:/data/logs/FritzLog.csv");
var csv = new CsvReader(reader);
csv.Parser.Configuration.Delimiter = ";";
csv.Configuration.HasHeaderRecord = true;
csv.Configuration.IgnoreHeaderWhiteSpace = true;
var records = csv.GetRecords<LogEntry>();
var node = new Uri("http://localhost:9200");
var settings = new ConnectionSettings(node);
settings.SetDefaultIndex("phonelog");
var client = new ElasticClient(settings);
client.DeleteIndex("phonelog");
client.CreateIndex(ci => ci.Index("phonelog").AddMapping<LogEntry>(m => m.MapFromAttributes()));
foreach (var record in records)
{
var result = client.Index(record);
Console.WriteLine(record + ", Result: " + result);
}
}
public ActionResult ReIndexAll()
{
var documents = db.DocumentModels.ToList();
var uriString = ConfigurationManager.AppSettings["SEARCHBOX_URL"];
var searchBoxUri = new Uri(uriString);
var settings = new ConnectionSettings(searchBoxUri);
settings.SetDefaultIndex(indexName);
var client = new ElasticClient(settings);
// delete index if exists at startup
if (client.IndexExists(indexName).Exists)
{
client.DeleteIndex(indexName);
}
// Create a new "sample" index with default settings
//client.CreateIndex("sample", new IndexSettings());
ICreateIndexRequest iCreateIndexReq = new CreateIndexRequest(indexName);
iCreateIndexReq.IndexSettings = new IndexSettings();
iCreateIndexReq.IndexSettings.NumberOfReplicas = 10;
//client.CreateIndex(iCreateIndexReq);
var resCreate = client.CreateIndex(indexName, s => s.AddMapping<DocumentModel>(f => f.MapFromAttributes()).NumberOfReplicas(1).NumberOfShards(10));
//client.CreateIndex()
// Index all documents
client.IndexMany<DocumentModel>(documents);
//client.Index()
ViewBag.Message = "Reindexing all database is complete!";
return RedirectToAction("Index");
}
public static IElasticClient ConfigureElastic()
{
Logger.Info("Setting up Elastic");
var connectionString = ConfigurationManager.ConnectionStrings["Elastic"];
if (connectionString == null)
throw new ArgumentException("No elastic connection string found");
var data = connectionString.ConnectionString.Split(';');
var url = data.FirstOrDefault(x => x.StartsWith("Url", StringComparison.CurrentCultureIgnoreCase));
if (url == null)
throw new ArgumentException("No URL parameter in elastic connection string");
var index = data.FirstOrDefault(x => x.StartsWith("DefaultIndex", StringComparison.CurrentCultureIgnoreCase));
if (string.IsNullOrEmpty(index))
throw new ArgumentException("No DefaultIndex parameter in elastic connection string");
index = index.Substring(13);
var node = new Uri(url.Substring(4));
var pool = new Elasticsearch.Net.SingleNodeConnectionPool(node);
var regex = new Regex("([+\\-!\\(\\){}\\[\\]^\"~*?:\\\\\\/>< ]|[&\\|]{2}|AND|OR|NOT)", RegexOptions.Compiled);
var settings = new Nest.ConnectionSettings(pool, (_) => new JsonNetSerializer(_))
.DefaultIndex(index)
.DefaultTypeNameInferrer(type =>
type.FullName
.Replace("Pulse.Presentation.ServiceStack.", "")
.Replace("Pulse.Application.Elastic.", "")
.Replace('.', '_')
)
.DefaultFieldNameInferrer(field => regex.Replace(field, ""));
#if DEBUG
settings = settings.DisableDirectStreaming();
#endif
var client = new ElasticClient(settings);
if (!client.IndexExists(index).Exists)
client.CreateIndex(index, i => i
.Settings(s => s
.NumberOfShards(8)
.NumberOfReplicas(0)
.Analysis(analysis => analysis
.TokenFilters(f => f.NGram("ngram", d => d.MinGram(1).MaxGram(15)))
.Analyzers(a => a
.Custom("default_index", t => t.Tokenizer("keyword").Filters(new[] { "standard", "lowercase", "asciifolding", "kstem", "ngram" }))
.Custom("suffix", t => t.Tokenizer("keyword").Filters(new[] { "standard", "lowercase", "asciifolding", "reverse" }))
)
)));
return client;
}
private static void Index(Document document, String operation)
{
var uriString = ConfigurationManager.AppSettings["SEARCHBOX_URL"];
var searchBoxUri = new Uri(uriString);
var settings = new ConnectionSettings(searchBoxUri);
settings.SetDefaultIndex("sample");
var client = new ElasticClient(settings);
if (!client.IndexExists("sample").Exists)
{
// Create a new "sample" index with default settings
client.CreateIndex("sample", new IndexSettings());
}
if (operation.Equals("delete"))
{
client.DeleteById("sample", "documents", document.DocumentId);
}
else
{
client.Index(document, "sample", "documents", document.DocumentId);
}
}
// Create index for filling data
// @indexName : whatever
public void ElasticSearchSetup(string indexName)
{
Uri node = new Uri(ElasticServer);
ConnectionSettings settings = new ConnectionSettings(node);
settings.DefaultIndex(indexName);
client = new ElasticClient(settings);
// create the index if it doesn't exist
if (!client.IndexExists(indexName).Exists)
{
client.CreateIndex(indexName);
}
}
static void Main(string[] args)
{
elasticSettings = new ConnectionSettings(new Uri("http://127.0.0.1:9200"))
.SetDefaultIndex("people");
client = new ElasticClient(elasticSettings);
client.DeleteIndex("people");
// Create an index
client.CreateIndex("people", c => c
.NumberOfReplicas(0)
.AddMapping<Person>(m => m.MapFromAttributes())
.NumberOfShards(1));
//client.MapFluent<Person>(m => m.IndexAnalyzer("standard")
// .Properties(props => props
// .String(s => s
// .Name(p => p.Message)
// .Index(FieldIndexOption.analyzed))
// .Number(n => n
// .Name(p => p.Age))
// .String(s => s
// .Name(p => p.FirstName))
// .String(s => s
// .Name(p => p.Sex))
// .String(s => s
// .Name(p => p.LastName))));
// Add some people
var jp = new Person { FirstName = "JP", LastName = "Toto", Age = 37, Message = "OMG yay ES!", Sex = "Male" };
var matt = new Person { FirstName = "Matt", LastName = "Toto", Age = 37, Message = "I'm JPs brother", Sex = "Male" };
var christine = new Person { FirstName = "Christine", LastName = "Toto", Age = 0, Message = "I'm JPs wife", Sex = "Female" };
var kevin = new Person { FirstName = "Kevin", LastName = "Smith", Age = 26, Message = "I'm JPs other brother", Sex = "Male" };
client.Index(jp);
client.Index(matt);
client.Index(christine);
client.Index(kevin);
client.Flush(true);
var results = client.Search<Person>(s => s
.MatchAll()
.FacetStatistical(fs => fs
.OnField(f => f.Age)
));
var facet = results.Facet<StatisticalFacet>(f => f.Age);
Console.WriteLine("Statistical Facets");
Console.WriteLine("");
Console.WriteLine("Max: {0}", facet.Max);
Console.WriteLine("Min: {0}", facet.Min);
Console.WriteLine("Std Dev: {0}", facet.StandardDeviation);
Console.WriteLine("Total: {0}", facet.Total);
Console.ReadKey();
Console.Clear();
Console.WriteLine("Histogram Facets");
Console.WriteLine("");
var facetResults = client.Search<Person>(s => s
.MatchAll()
.FacetHistogram(fs => fs
.OnField(f => f.Age)
.Interval(1)
));
var facet2 = facetResults.Facet<HistogramFacet>(f => f.Age);
foreach (var item in facet2.Items)
{
Console.WriteLine("Key: {0} Count: {1}", item.Key, item.Count);
}
Console.ReadKey();
Console.Clear();
Console.WriteLine("Term Facets");
Console.WriteLine("");
var facetResults2 = client.Search<Person>(s => s
.From(0)
.Size(10)
.MatchAll()
.FacetTerm(t => t.OnField(f => f.LastName).Size(20))
);
var facet3 = facetResults2.Facet<TermFacet>(f => f.LastName);
foreach (var item in facet3.Items)
{
Console.WriteLine("Key: {0} Count: {1}", item.Term, item.Count);
}
Console.ReadKey();
}
private void EagerCreateIndex(Contexts.Mouths.Mouth destination)
{
IGetMappingResponse mapping = null;
try
{
if (destination.DeleteExisting)
{
// Get previous mapping
mapping = _client.GetMapping <object>(m =>
{
m.Index(destination.Index);
m.Type(destination.Type);
return(m);
});
_client.DeleteMapping(new DeleteMappingRequest(destination.Index, destination.Type));
}
}
catch (Exception ex)
{
log.Error(ex);
}
try
{
var index = _client.CreateIndex(c => c
.Index(destination.Index)
.InitializeUsing(new Nest.IndexSettings())
);
_indexCreated = true;
if (mapping != null)
{
// Use previous mapping to create mapping for new index
log.Info("Adding previously pulled mapping");
_client.Map <object>(m =>
{
m.InitializeUsing(mapping.Mapping);
m.Index(destination.Index);
m.Type(destination.Type);
return(m);
});
}
else
{
// Process parent mapping as normal for type creation
if (destination.Mapping != null)
{
_client.Map <object>(m =>
{
m.Index(destination.Index);
m.Type(destination.Type);
if (destination.Mapping.Parent != null)
{
m.SetParent(destination.Mapping.Parent.Type);
}
return(m);
});
}
}
}
catch (Exception ex)
{
log.Error(ex);
throw;
}
}
private static void Index(DocumentModel document, String operation)
{
var uriString = ConfigurationManager.AppSettings["SEARCHBOX_URL"];
var searchBoxUri = new Uri(uriString);
var settings = new ConnectionSettings(searchBoxUri);
settings.SetDefaultIndex(indexName);
var client = new ElasticClient(settings);
if (!client.IndexExists(indexName).Exists)
{
// Create a new "sample" index with default settings
ICreateIndexRequest iCreateIndexReq = new CreateIndexRequest(indexName);
iCreateIndexReq.IndexSettings = new IndexSettings();
iCreateIndexReq.IndexSettings.NumberOfReplicas = 10;
//iCreateIndexReq.IndexSettings.Mappings = new List<RootObjectMapping>();
//RootObjectMapping rootObjectMapping = new RootObjectMapping();
//rootObjectMapping.AllFieldMapping()
//iCreateIndexReq.IndexSettings.Mappings.
//client.CreateIndex(iCreateIndexReq);
//client.CreateIndex(indexName,s=>s.)
var resCreate = client.CreateIndex(indexName, s => s.AddMapping<DocumentModel>(f => f.MapFromAttributes()).NumberOfReplicas(1).NumberOfShards(10));
//client.CreateIndex(indexName, new IndexSettings());
//client.create
}
if (operation.Equals("delete"))
{
//client.DeleteById(indexName, "documents", document.DocumentId);
IDeleteByQueryRequest iDeleteByQueryRequest = new DeleteByQueryRequest();
//IDeleteIndexRequest delReq = new DeleteIndexRequest(indexName);
//client.DeleteIndex()
//client.DeleteByQuery(new DeleteByQueryRequest())
client.Delete<DocumentModel>(f => f.Id(document.DocumentId).Index(indexName).Refresh());
//var response = this.Client.Delete<ElasticsearchProject>(f=>f.Id(newDocument.Id).Index(newIndex).Refresh());
}
else
{
//IIndexRequest<DocumentModel> indexRequest = IndexRequest<DocumentModel>();
//client.Index(i)
//client.Index(document, indexName, "documents", document.DocumentId);
//IndexDescriptor indexDesc = IndexDescriptor;
//IndexRequestParameters indexParameter = new IndexRequestParameters();
// indexParameter.Replication(1);
client.Index(document, i => i.Id(document.DocumentId).Index(indexName));
//client.Index();
//client.Index()
}
}
public void CreateIndex(string name, string elUri)
{
Node = new Uri(elUri);
var connectionPool = new SniffingConnectionPool(new[] { Node });
Settings = new ConnectionSettings(Node);
Client = new ElasticClient(Settings);
var indexsettings = new IndexSettings();
indexsettings.NumberOfReplicas = 1;
indexsettings.NumberOfShards = 5;
Client.CreateIndex(c => c
.Index(name)
.InitializeUsing(indexsettings)
.AddMapping<activitylog>(m => m.MapFromAttributes()));
}
public static void AddAutocompleteMappingToIndex(ElasticClient client)
{
//http://stackoverflow.com/questions/30285065/elasticsearch-nest-client-creating-multi-field-fields-with-completion
client.CreateIndex(descriptor => descriptor
.Index(EsIndexName)
.AddMapping<Skill>(m => m
.Properties(p => p.MultiField(mf => mf
.Name(n => n.Name)
.Fields(f => f
.String(s => s.Name(n => n.Name).Index(FieldIndexOption.Analyzed))
.String(s => s.Name(n => n.Name.Suffix("sortable")).Index(FieldIndexOption.NotAnalyzed))
.String(s => s.Name(n => n.Name.Suffix("autocomplete")).IndexAnalyzer("shingle_analyzer"))))))
.AddMapping<Certification>(m => m
.Properties(p => p.MultiField(mf => mf
.Name(n => n.Name)
.Fields(f => f
.String(s => s.Name(n => n.Name).Index(FieldIndexOption.Analyzed))
.String(s => s.Name(n => n.Name.Suffix("sortable")).Index(FieldIndexOption.NotAnalyzed))
.String(s => s.Name(n => n.Name.Suffix("autocomplete")).IndexAnalyzer("shingle_analyzer"))))))
.Analysis(a => a
.Analyzers(b => b.Add("shingle_analyzer", new CustomAnalyzer
{
Tokenizer = "standard",
Filter = new List<string> {"lowercase", "shingle_filter"}
}))
.TokenFilters(b => b.Add("shingle_filter", new ShingleTokenFilter
{
MinShingleSize = 2,
MaxShingleSize = 5
})))
);
}
private static void GenerateSuffixCompletionSearchMapping(ElasticClient client)
{
var createResult = client.CreateIndex(index => index
.AddMapping<EmployeeSkillsDocument>(tmd => tmd
.Properties(props => props
.Completion(s =>
s.Name(p => p.Skills.Suffix("completion"))
.IndexAnalyzer("standard")
.SearchAnalyzer("standard")
.MaxInputLength(20)
.Payloads()
.PreservePositionIncrements()
.PreserveSeparators())
)
)
);
}
private void EnsureIndexExists(ElasticClient esClient, string indexName)
{
var indexExistsRequest = new IndexExistsRequest(indexName);
var indexExistsResult = esClient.IndexExists(indexExistsRequest);
if (indexExistsResult.Exists == false)
{
var createIndexRequest = new CreateIndexRequest(indexName);
var createIndexResponse = esClient.CreateIndex(createIndexRequest);
if (createIndexResponse.Acknowledged == false)
{
throw new ApplicationException(string.Format("Kunne ikke lave {0} index", indexName));
}
}
}
protected static void GenerateAndIndex(ElasticClient client, string indexName, int numMessages, int bufferSize)
{
var msgGenerator = new MessageGenerator();
var tasks = new List<Task>();
var partitionedMessages = msgGenerator.Generate(numMessages).Partition(bufferSize);
client.CreateIndex(indexName, c => c
.NumberOfReplicas(0)
.NumberOfShards(1)
.Settings(s => s.Add("refresh_interval", "-1"))
.AddMapping<Message>(p=>p.MapFromAttributes())
);
Interlocked.Exchange(ref NumSent, 0);
foreach (var messages in partitionedMessages)
{
var t = client.IndexManyAsync(messages, indexName)
.ContinueWith(tt =>
{
Interlocked.Add(ref NumSent, bufferSize);
Console.WriteLine("Sent {0:0,0} messages to {1}, {2}", NumSent, indexName, tt.Result.Took);
})
;
tasks.Add(t);
}
Task.WaitAll(tasks.ToArray());
client.UpdateSettings(u => u
.Index(indexName)
.RefreshInterval("1s")
);
}
public ActionResult ReIndexAll()
{
var documents = db.Documents.ToList();
var uriString = ConfigurationManager.AppSettings["SEARCHBOX_URL"];
var searchBoxUri = new Uri(uriString);
var settings = new ConnectionSettings(searchBoxUri);
settings.SetDefaultIndex("sample");
var client = new ElasticClient(settings);
// delete index if exists at startup
if (client.IndexExists("sample").Exists)
{
client.DeleteIndex("sample");
}
// Create a new "sample" index with default settings
client.CreateIndex("sample", new IndexSettings());
// Index all documents
client.IndexMany<Document>(documents);
ViewBag.Message = "Reindexing all database is complete!";
return RedirectToAction("Index");
}
