Exemple #1
0
        public async Task <bool> Initialize()
        {
            await _client.CreateIndexAsync(typeof(Basket.Models.BasketIndex).FullName.ToLower(), i => i
                                           .Settings(s => s
                                                     .NumberOfShards(3)
                                                     .TotalShardsPerNode(3)
                                                     .NumberOfReplicas(0)
                                                     .Analysis(analysis => analysis.AutoCompleteAnalyzers())
                                                     )
                                           .Mappings(mappings => mappings.Map <Basket.Models.BasketIndex>(map =>
                                                                                                          map.Properties(props =>
                                                                                                                         props.Keyword(s => s.Name(x => x.Id).IgnoreAbove(256))
                                                                                                                         .Keyword(s => s.Name(x => x.CustomerId).IgnoreAbove(256))
                                                                                                                         .Text(s => s.Name(x => x.Customer).Fields(x => x.AutoCompleteFields()))
                                                                                                                         .Number(s => s.Name(x => x.TotalItems).Type(NumberType.Long))
                                                                                                                         .Number(s => s.Name(x => x.TotalQuantity).Type(NumberType.Long))
                                                                                                                         .Number(s => s.Name(x => x.SubTotal).Type(NumberType.Long))
                                                                                                                         .Date(s => s.Name(x => x.Created).Format("epoch_millis"))
                                                                                                                         .Date(s => s.Name(x => x.Updated).Format("epoch_millis"))
                                                                                                                         )))).ConfigureAwait(false);

            await _client.CreateIndexAsync(typeof(Basket.Entities.Item.Models.BasketItemIndex).FullName.ToLower(), i => i
                                           .Settings(s => s
                                                     .NumberOfShards(3)
                                                     .TotalShardsPerNode(3)
                                                     .NumberOfReplicas(0)
                                                     .Analysis(analysis => analysis.AutoCompleteAnalyzers())
                                                     )
                                           .Mappings(mappings => mappings.Map <Basket.Entities.Item.Models.BasketItemIndex>(map =>
                                                                                                                            map.Properties(props =>
                                                                                                                                           props.Keyword(s => s.Name(x => x.Id).IgnoreAbove(256))
                                                                                                                                           .Keyword(s => s.Name(x => x.BasketId).IgnoreAbove(256))
                                                                                                                                           .Keyword(s => s.Name(x => x.ProductId).IgnoreAbove(256))
                                                                                                                                           .Binary(s => s.Name(x => x.ProductPictureContents))
                                                                                                                                           .Keyword(s => s.Name(x => x.ProductPictureContentType).IgnoreAbove(256))
                                                                                                                                           .Text(s => s.Name(x => x.ProductName).Fields(x => x.AutoCompleteFields()))
                                                                                                                                           .Text(s => s.Name(x => x.ProductDescription).Fields(x => x.AutoCompleteFields()))
                                                                                                                                           .Number(s => s.Name(x => x.ProductPrice).Type(NumberType.Long))
                                                                                                                                           .Number(s => s.Name(x => x.Quantity).Type(NumberType.Long))
                                                                                                                                           .Number(s => s.Name(x => x.SubTotal).Type(NumberType.Long))
                                                                                                                                           )))).ConfigureAwait(false);

            await _client.CreateIndexAsync(typeof(Basket.Services.BasketsUsingProductHandler.ProductBaskets).FullName.ToLower(), i => i
                                           .Settings(s => s
                                                     .NumberOfShards(3)
                                                     .TotalShardsPerNode(3)
                                                     .NumberOfReplicas(0)
                                                     .Analysis(analysis => analysis.AutoCompleteAnalyzers())
                                                     )
                                           .Mappings(mappings => mappings.Map <Basket.Services.BasketsUsingProductHandler.ProductBaskets>(map =>
                                                                                                                                          map.Properties(props =>
                                                                                                                                                         props.Keyword(s => s.Name(x => x.Id).IgnoreAbove(256))
                                                                                                                                                         .Keyword(s => s.Name(x => x.Baskets).IgnoreAbove(256))
                                                                                                                                                         )))).ConfigureAwait(false);

            this.Done = true;
            return(true);
        }
Exemple #2
0
 private Task CreateHighwaysIndex(string highwaysIndexName)
 {
     return(_elasticClient.CreateIndexAsync(highwaysIndexName,
                                            c => c.Mappings(
                                                ms => ms.Map <Feature>(m =>
                                                                       m.Properties(ps => ps.GeoShape(g => g.Name(f => f.Geometry)
                                                                                                      .Tree(GeoTree.Geohash)
                                                                                                      .TreeLevels(10)
                                                                                                      .DistanceErrorPercentage(0.2)))
                                                                       )
                                                )
                                            ));
 }
        public async Task CreateAsync()
        {
            var indexName = await m_ElasticClient.GetNextIndexNameByAliasAsync(Settings.Alias);

            var createResponse = await m_ElasticClient.CreateIndexAsync(
                indexName,
                mappings : new MappingsDescriptor().Map <Job>(m => m
                                                              .Properties(p => p
                                                                          .String(s => s
                                                                                  .NotAnalyzed()
                                                                                  .Name(j => j.Id)))
                                                              .Properties(p => p
                                                                          .String(s => s
                                                                                  .Analyzer("ik")
                                                                                  .SearchAnalyzer("ik_smart")
                                                                                  .Name(j => j.Name)))
                                                              .Properties(p => p
                                                                          .Number(n => n
                                                                                  .Name(j => j.Type)))
                                                              .Properties(p => p
                                                                          .String(s => s
                                                                                  .NotAnalyzed()
                                                                                  .Name(j => j.Contact)))));

            if (createResponse.Acknowledged)
            {
                await m_ElasticClient.SwapAliasAsync(Settings.Alias, indexName);
            }
        }
Exemple #4
0
        private static void LoadMovies(IElasticClient elasticClient, string indexName)
        {
            var settingsResponse = elasticClient.GetIndexSettingsAsync(x => x.Index(indexName)).Result;

            if (settingsResponse.ServerError?.Status == 404)
            {
                var response = elasticClient.CreateIndexAsync(indexName, d => d
                                                              .Mappings(ms => ms
                                                                        .Map <MovieSearchItem>(m => m.AutoMap())
                                                                        )
                                                              ).Result;

                if (response.IsValid == false)
                {
                    throw new Exception(string.Format("{0}: {1}",
                                                      response.ServerError.Status,
                                                      response.ServerError.Error), response.OriginalException);
                }
            }

            var movies = GetMovies().ToList();

            foreach (var movie in movies)
            {
                elasticClient.Index(movie, i => i.Index(indexName));
            }
        }
Exemple #5
0
        public async Task <IActionResult> CreateEsIndex()
        {
            try
            {
                var response = await _esClient.CreateIndexAsync("users", c =>
                {
                    return(c.Mappings(ms =>
                    {
                        return ms.Map <AppUser>(m =>
                        {
                            return m.AutoMap <UserProperty>().AutoMap <AppUser>();
                        });
                    }));
                });

                //写入成功
                if (response.IsValid)
                {
                    return(Ok());
                }
            }
            catch (Exception e)
            {
                throw;
            }
            return(BadRequest());
        }
Exemple #6
0
        public async Task <CreateIndicesQueryResult> Handle(CreateIndicesQuery request, CancellationToken cancellationToken)
        {
            var createNoteIndexResponse = await _elasticClient.CreateIndexAsync(Constants.Constants.IndexNameNote, c => c
                                                                                .Mappings(ms => ms
                                                                                          .Map <Note>(m => m.AutoMap())
                                                                                          )
                                                                                );

            var createAuthorIndexResponse = await _elasticClient.CreateIndexAsync(Constants.Constants.IndexNameAuthor, c => c
                                                                                  .Mappings(ms => ms
                                                                                            .Map <Author>(m => m.AutoMap())
                                                                                            )
                                                                                  );

            return(new CreateIndicesQueryResult(createNoteIndexResponse.Acknowledged && createAuthorIndexResponse.Acknowledged));
        }
        public async Task CreateAsync(params IElasticsearchIndexContributor[] additionalContributors)
        {
            var contribCollection = new SortedSet <IElasticsearchIndexContributor>(_contributors);
            var indexName         = _client.Infer.DefaultIndex;

            contribCollection.UnionWith(additionalContributors);

            indexName = PreIndexContribution(contribCollection.OfType <IElasticsearchIndexPreCreationContributor>(), indexName);

            try
            {
                var indexResponse = await _client.CreateIndexAsync(i =>
                {
                    i.Index(indexName);
                    ContributeCore(i, contribCollection.OfType <IElasticsearchIndexCreationContributor>());
                    return(i);
                });

                OnCompleted(contribCollection.OfType <IElasticsearchIndexCreationSuccessContributor>(), indexResponse);
            }
            catch (Exception ex)
            {
                OnError(contribCollection.OfType <IElasticsearchIndexCreationFailureContributor>(), ex);
                throw;
            }
        }
        public async Task EnureIndexExistsAsync(string environmentName, IElasticClient client)
        {
            var type      = typeof(T);
            var indexName = $"{environmentName.ToLower()}-{IndexName}";

            await _mutex.WaitAsync();

            try
            {
                if (!client.ConnectionSettings.DefaultIndices.TryGetValue(type, out var defaultIndexName) || indexName != defaultIndexName)
                {
                    var response = await client.IndexExistsAsync(indexName).ConfigureAwait(false);

                    if (!response.Exists)
                    {
                        await client.CreateIndexAsync(indexName, i => i
                                                      .Mappings(ms => ms
                                                                .Map <T>(m =>
                        {
                            Map(m);
                            return(m);
                        })
                                                                )
                                                      );
                    }

                    client.ConnectionSettings.DefaultIndices[type] = indexName;
                }
            }
            finally
            {
                _mutex.Release();
            }
        }
        private async Task SetupIndexAsync(IElasticClient connection, string indexName, string entityName, bool forceCreate)
        {
            var exists = Wrap(await connection.IndexExistsAsync(x => x.Index(indexName)).ConfigureAwait(false)).Exists;

            if (exists && forceCreate)
            {
                Wrap(await connection.DeleteIndexAsync(x => x.Index(indexName)).ConfigureAwait(false));
                exists = false;
            }

            if (!exists)
            {
                var createResponse = Wrap(await connection.CreateIndexAsync(createIndexDescriptor => createIndexDescriptor
                                                                            .Index(indexName)
                                                                            .Analysis(a => a
                                                                                      .Analyzers(x => x.Add("lowercaseKeyword", new CustomAnalyzer {
                    Tokenizer = "keyword",
                    Filter    = new[] { "standard", "lowercase" }
                }))
                                                                                      )
                                                                            .AddMapping <TUser>(m => m
                                                                                                .MapFromAttributes()
                                                                                                .IncludeInAll(false)
                                                                                                .IdField(x => x.Path("id"))
                                                                                                .Type(entityName)
                                                                                                )
                                                                            ).ConfigureAwait(false));

                AssertIndexCreateSuccess(createResponse);
                await SeedAsync().ConfigureAwait(false);
            }
        }
Exemple #10
0
		/// <summary>
		/// The create index API allows to instantiate an index. Elasticsearch provides support for multiple indices, 
		/// including executing operations across several indices.
		/// <para> </para>http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/indices-create-index.html
		/// </summary>
		/// <param name="client"></param>
		/// <param name="index">The name of the index to be created</param>
		/// <param name="createIndexSelector">A descriptor that further describes the parameters for the create index operation</param>
		public static Task<IIndicesOperationResponse> CreateIndexAsync(this IElasticClient client, string index,
			Func<CreateIndexDescriptor, CreateIndexDescriptor> createIndexSelector = null)
		{
			index.ThrowIfNullOrEmpty("index");
			createIndexSelector = createIndexSelector ?? (c => c);
			return client.CreateIndexAsync(c => createIndexSelector(c).Index(index));
		}
Exemple #11
0
        private async Task CreateMapping <T>(IElasticClient client, Func <PutMappingDescriptor <T>, IPutMappingRequest> mapping) where T : class
        {
            if (!(await client.IndexExistsAsync(client.ConnectionSettings.DefaultIndex)).Exists)
            {
                await client.CreateIndexAsync(client.ConnectionSettings.DefaultIndex);

                await client.MapAsync <T>(mapping);
            }
        }
        /// <summary>
        /// 创建索引
        /// </summary>
        /// <typeparam name="TDocument">文档类型</typeparam>
        /// <param name="index">索引名称。注意:必须小写</param>
        /// <param name="alias">别名名称。注意:必须小写</param>
        /// <param name="cancellationToken">取消令牌</param>
        public async Task CreateIndexAsync <TDocument>(string index, string alias = null, CancellationToken cancellationToken = default) where TDocument : class
        {
            await _client.CreateIndexAsync <TDocument>(index, _options.NumberOfShards, _options.NumberOfReplicas, cancellationToken);

            if (alias.IsEmpty() == false)
            {
                await _client.Indices.PutAliasAsync(index, alias, ct : cancellationToken);
            }
        }
        private async Task EnsureIndexesExist()
        {
            var existsResponse = await _elasticClient.IndexExistsAsync(PagesIndexName);

            if (!existsResponse.Exists)
            {
                await _elasticClient.CreateIndexAsync(PagesIndexName);
            }
        }
Exemple #14
0
        public async Task CreateIfNotExists(IndexDefinition searchIndexDefinition)
        {
            var indexName      = searchIndexDefinition.ElasticIndexName();
            var existsResponse = await _elasticClient.IndexExistsAsync(new IndexExistsRequest(indexName));

            if (!existsResponse.Exists)
            {
                var mappings       = searchIndexDefinition.CreateElasticMappings();
                var createResponse = await _elasticClient.CreateIndexAsync(new CreateIndexRequest(searchIndexDefinition.ElasticIndexName())
                {
                    Mappings = mappings
                });

                if (!createResponse.IsValid)
                {
                    throw new Exception("Error creating index.", createResponse.OriginalException);
                }
            }
        }
        /// <summary>
        /// Creates the default ElasticSearch index.
        /// </summary>
        public async Task <ICreateIndexResponse> CreateIndex()
        {
            if (!(await _client.IndexExistsAsync(_serviceConfig.IndexName)).Exists)
            {
                return(await _client.CreateIndexAsync(_serviceConfig.IndexName, cid => cid
                                                      .Mappings(md => SearchConstants.Mappings(md))
                                                      ));
            }

            return(null);
        }
Exemple #16
0
 public async Task CreateIndex(IElasticClient elasticClient, string indexName)
 {
     if (!elasticClient.IndexExists(indexName).Exists)
     {
         await elasticClient.CreateIndexAsync(indexName, c => c.InitializeUsing(new IndexState {
             Settings = new IndexSettings {
                 NumberOfReplicas = 1, NumberOfShards = 2
             }
         }));
     }
 }
Exemple #17
0
        public async Task CreateAsync()
        {
            var newindexName = indexNameResolver.ResolveUniqueIndexName(UmbracoSearchFactory.ActiveIndexName);

            var result = await client.CreateIndexAsync(newindexName, WithCreateIndexDescriptorCore).ConfigureAwait(false);

            if (result.IsValid)
            {
                Parallel.ForEach(UmbracoSearchFactory.GetContentIndexServices(), c => c.UpdateIndexTypeMapping(newindexName));
                Parallel.ForEach(UmbracoSearchFactory.GetMediaIndexServices(), c => c.UpdateIndexTypeMapping(newindexName));
            }
        }
        private async Task <ICreateIndexResponse> Create <TModel>(IElasticClient client, string indexName)
            where TModel : class
        {
            var response = await client.GetIndexAsync(indexName);

            if (!response.IsValid)
            {
                return(await client.CreateIndexAsync(indexName, c => c.Mappings(ms => ms.Map <TModel>(m => m.AutoMap()))));
            }
            else
            {
                return(null);
            }
        }
Exemple #19
0
        /// <summary>
        /// Create index Tv by date
        /// </summary>
        /// <param name="dateTime"></param>
        public async Task CreateIndexTvByDateAsync(DateTime dateTime, CancellationToken cancellationToken = default(CancellationToken))
        {
            var keywordProperty = new PropertyName("keyword");

            string index = $"xmltv-{dateTime.ToString("d")}";

            if (!(await _elasticClient.IndexExistsAsync(index, cancellationToken: cancellationToken)).Exists)
            {
                var response = await _elasticClient.CreateIndexAsync(index, c => c
                                                                     .Mappings(x => x.Map <tv>(tv => tv.Properties(p =>
                                                                                                                   p.Object <tvChannel>(tvc => tvc.AutoMap())
                                                                                                                   .Object <tvProgramme>(tvp => tvp.AutoMap())
                                                                                                                   ))), cancellationToken : cancellationToken);
            }
        }
Exemple #20
0
        public async Task ReIndex <T>(IReadOnlyCollection <T> items) where T : class, IEntity
        {
            var exists = await _elasticClient.IndexExistsAsync(_indexName);

            if (exists.Exists)
            {
                await _elasticClient.DeleteIndexAsync(_indexName);

                await _elasticClient.CreateIndexAsync(_indexName);
            }

            await Task.WhenAll(items.Select(async item => await AddItem(item)));

            await _elasticClient.RefreshAsync(new RefreshRequest(_indexName));
        }
Exemple #21
0
        /// <summary>
        /// 如果索引不存在就创建
        /// </summary>
        /// <param name="client"></param>
        /// <param name="indexName"></param>
        /// <param name="selector"></param>
        /// <returns></returns>
        public static async Task CreateIndexIfNotExistsAsync(this IElasticClient client, string indexName, Func <CreateIndexDescriptor, ICreateIndexRequest> selector = null)
        {
            indexName = indexName.ToLower();
            var exist_response = await client.IndexExistsAsync(indexName);

            exist_response.ThrowIfException();

            if (exist_response.Exists)
            {
                return;
            }

            var response = await client.CreateIndexAsync(indexName, selector);

            response.ThrowIfException();
        }
Exemple #22
0
        public async Task Start()
        {
            _client = new ElasticClient(_settings);
            var nodeInfo = await _client.NodesInfoAsync();

            if (nodeInfo.Nodes.Values.Any(x => Convert.ToUInt32(x.Version.Split('.')[0]) < 6))
            {
                throw new NotSupportedException("Elasticsearch verison 6 or greater is required");
            }

            var exists = await _client.IndexExistsAsync(_indexName);

            if (!exists.Exists)
            {
                await _client.CreateIndexAsync(_indexName);
            }
        }
Exemple #23
0
        /// <summary>
        /// 初始化索引映射
        /// </summary>
        /// <param name="client">ES客户端</param>
        /// <param name="indexName">索引名</param>
        public static async Task InitializeIndexMapAsync(this IElasticClient client, string indexName)
        {
            var newName = indexName + DateTime.Now.Ticks;
            var result  = await client.CreateIndexAsync(newName,
                                                        x => x.Index(newName)
                                                        .Settings(o =>
                                                                  o.NumberOfShards(1)
                                                                  .NumberOfReplicas(1)
                                                                  .Setting("max_result_window", int.MaxValue)));

            if (result.Acknowledged)
            {
                await client.AliasAsync(x => x.Add(o => o.Index(newName).Alias(indexName)));

                return;
            }
            throw new ElasticsearchException($"创建索引 {indexName} 失败:{result.ServerError.Error.Reason}");
        }
Exemple #24
0
        private async Task CreateMappings(IElasticClient elasticClient, IndexName indexName, TypeName typeName)
        {
            var result = await elasticClient.IndexExistsAsync(indexName);

            if (!result.Exists)
            {
                ICreateIndexRequest createIndexRequest;
                switch (indexName.Name)
                {
                case "records":
                    createIndexRequest = new CreateIndexDescriptor(indexName)
                                         .Mappings(s => s
                                                   .Map(typeName, tm => tm
                                                        .Properties(p => p.Keyword(k => k.Name("OwnedBy")))
                                                        .Properties(p => p.Keyword(k => k.Name("FileId")))
                                                        .Properties(p => p.Object <dynamic>(f => f.Name("Properties")
                                                                                            .Properties(np => np.Object <dynamic>(t => t.Name("ChemicalProperties")
                                                                                                                                  .Properties(cp => cp.Text(tp => tp.Name("Value")))))))));
                    break;

                default:
                    createIndexRequest = new CreateIndexDescriptor(indexName)
                                         .Mappings(s => s
                                                   .Map(typeName, tm => tm
                                                        .Properties(p => p
                                                                    .Keyword(k => k.Name("OwnedBy"))
                                                                    )));
                    break;
                }

                try
                {
                    await elasticClient.CreateIndexAsync(createIndexRequest);

                    Log.Information($"Created mapping for index: '{indexName}', type: '{typeName}'");
                }
                catch (ElasticsearchClientException e)
                {
                    Log.Error($"Creating mapping server error: {e.Response.ServerError}");
                }
            }
        }
        private static async Task <ICreateIndexResponse> CreateIndexAsync(
            IElasticClient client,
            IIndexSettings indexSettings,
            MappingsDescriptor mappings,
            string indexName)
        {
            indexSettings = indexSettings ?? new IndexSettings();
            mappings      = mappings ?? new MappingsDescriptor();

            var response = await client.CreateIndexAsync(
                indexName,
                createDescriptor => createDescriptor
                .Settings(settingDescriptor => settingDescriptor
                          .NumberOfShards(indexSettings.NumberOfShards)
                          .FileSystemStorageImplementation(
                              indexSettings.FileSystemStorageImplementation))
                .Mappings(mappingsDescriptor => mappings));

            return(response);
        }
Exemple #26
0
        private async Task CreateIndex(IElasticClient client)
        {
            var indexAsync = await client.CreateIndexAsync(_setup.IndexName, i => i
                                                           .Mappings(m => m.Map <EssayDocument>(MapEssay))
                                                           .Settings(s => s
                                                                     .Analysis(a => a
                                                                               .Analyzers(aa => aa
                                                                                          .Snowball(WithStopwordsAnalyzerIdentifier, sd => sd.Language(SnowballLanguage.Russian)
                                                                                                    .StopWords("как", "почему", "зачем", "очевидно")
                                                                                                    )
                                                                                          .Snowball(ForAllWordsAnalyzerIdentifier, sd => sd.Language(SnowballLanguage.Russian))
                                                                                          )
                                                                               .CharFilters(cf => cf.HtmlStrip("html"))
                                                                               )));

            if (!indexAsync.IsValid)
            {
                _logger.LogError("Index creation operation is reported as invalid.");
            }
        }
Exemple #27
0
        public async Task Create_Indices_when_index_is_incorrectly_named_same_as_index_alias()
        {
            // Arrange
            await _elasticClient.CreateIndexAsync(Constants.ElasticSearchIndices.ProjectsIndexName);

            // Act
            var indecisResult = await _elasticClient.CatIndicesAsync();

            await _elasticSearchIndexService.CreateIndices();

            var createdIndecisResult = await _elasticClient.CatIndicesAsync();

            // Assert
            indecisResult.Records.Count.Should().Be(1);
            indecisResult.Records.Should().Contain((index) => index.Index == Constants.ElasticSearchIndices.ProjectsIndexName);

            createdIndecisResult.Records.Count.Should().BeGreaterThan(1);
            createdIndecisResult.Records.Count.Should().Be(5);
            createdIndecisResult.Records.Should().NotContain((index) => index.Index == Constants.ElasticSearchIndices.ProjectsIndexName);
        }
Exemple #28
0
        public async Task <bool> Initialize()
        {
            await _client.CreateIndexAsync(typeof(Payment.Payment.Models.PaymentIndex).FullName.ToLower(), i => i
                                           .Settings(s => s
                                                     .NumberOfShards(3)
                                                     .TotalShardsPerNode(3)
                                                     .NumberOfReplicas(0)
                                                     .Analysis(analysis => analysis
                                                               .TokenFilters(f => f.NGram("ngram", d => d.MinGram(3).MaxGram(4)))
                                                               .Analyzers(a => a
                                                                          .Custom("default",
                                                                                  t => t.Tokenizer("keyword").Filters(new[]
                                                                                                                      { "standard", "lowercase", "asciifolding", "kstem", "ngram" }))
                                                                          )
                                                               )
                                                     )
                                           .Mappings(mappings => mappings.Map <Payment.Payment.Models.PaymentIndex>(map =>
                                                                                                                    map.Properties(props =>
                                                                                                                                   props.Keyword(s => s.Name("Id").IgnoreAbove(256).Norms(false).IndexOptions(IndexOptions.Docs))
                                                                                                                                   .Keyword(s => s.Name("UserName").IgnoreAbove(256).Norms(false).IndexOptions(IndexOptions.Docs))
                                                                                                                                   .Keyword(s => s.Name("GivenName").IgnoreAbove(256).Norms(false).IndexOptions(IndexOptions.Docs))
                                                                                                                                   .Keyword(s => s.Name("Status").IgnoreAbove(256).Norms(false).IndexOptions(IndexOptions.Docs))
                                                                                                                                   .Keyword(s => s.Name("StatusDescription").IgnoreAbove(256).Norms(false).IndexOptions(IndexOptions.Docs))
                                                                                                                                   .Keyword(s => s.Name("OrderId").IgnoreAbove(256).Norms(false).IndexOptions(IndexOptions.Docs))
                                                                                                                                   .Number(s => s.Name("TotalPayment").Type(NumberType.Long))
                                                                                                                                   .Keyword(s => s.Name("PaymentMethodCardholder").IgnoreAbove(256).Norms(false).IndexOptions(IndexOptions.Docs))
                                                                                                                                   .Keyword(s => s.Name("PaymentMethodMethod").IgnoreAbove(256).Norms(false).IndexOptions(IndexOptions.Docs))
                                                                                                                                   .Keyword(s => s.Name("Reference").IgnoreAbove(256).Norms(false).IndexOptions(IndexOptions.Docs))
                                                                                                                                   .Number(s => s.Name("Created").Type(NumberType.Long))
                                                                                                                                   .Number(s => s.Name("Updated").Type(NumberType.Long))
                                                                                                                                   .Number(s => s.Name("Settled").Type(NumberType.Long))
                                                                                                                                   )))).ConfigureAwait(false);


            this.Done = true;
            return(true);
        }
Exemple #29
0
        public async Task <bool> Initialize()
        {
            await _client.CreateIndexAsync(typeof(Role.Models.RoleIndex).FullName.ToLower(), i => i
                                           .Settings(s => s
                                                     .NumberOfShards(3)
                                                     .TotalShardsPerNode(3)
                                                     .NumberOfReplicas(0)
                                                     .Analysis(analysis => analysis
                                                               .TokenFilters(f => f.NGram("ngram", d => d.MinGram(3).MaxGram(4)))
                                                               .Analyzers(a => a
                                                                          .Custom("default",
                                                                                  t => t.Tokenizer("keyword").Filters(new[]
                                                                                                                      { "standard", "lowercase", "asciifolding", "kstem", "ngram" }))
                                                                          )
                                                               )
                                                     )
                                           .Mappings(mappings => mappings.Map <Role.Models.RoleIndex>(map =>
                                                                                                      map.Properties(props =>
                                                                                                                     props.Keyword(s => s.Name("Id").IgnoreAbove(256).Norms(false).IndexOptions(IndexOptions.Docs))
                                                                                                                     .Keyword(s => s.Name("Name").IgnoreAbove(256).Norms(false).IndexOptions(IndexOptions.Docs))
                                                                                                                     .Number(s => s.Name("Users").Type(NumberType.Long).IgnoreMalformed())
                                                                                                                     .Boolean(s => s.Name("Disabled"))
                                                                                                                     )))).ConfigureAwait(false);


            await _client.CreateIndexAsync(typeof(User.Models.User).FullName.ToLower(), i => i
                                           .Settings(s => s
                                                     .NumberOfShards(3)
                                                     .TotalShardsPerNode(3)
                                                     .NumberOfReplicas(0)
                                                     .Analysis(analysis => analysis
                                                               .TokenFilters(f => f.NGram("ngram", d => d.MinGram(3).MaxGram(4)))
                                                               .Analyzers(a => a
                                                                          .Custom("default",
                                                                                  t => t.Tokenizer("keyword").Filters(new[]
                                                                                                                      { "standard", "lowercase", "asciifolding", "kstem", "ngram" }))
                                                                          )
                                                               )
                                                     )
                                           .Mappings(mappings => mappings.Map <User.Models.User>(map =>
                                                                                                 map.Properties(props =>
                                                                                                                props.Keyword(s => s.Name("Id").IgnoreAbove(256).Norms(false).IndexOptions(IndexOptions.Docs))
                                                                                                                .Keyword(s => s.Name("GivenName").IgnoreAbove(256).Norms(false).IndexOptions(IndexOptions.Docs))
                                                                                                                .Boolean(s => s.Name("Disabled"))
                                                                                                                .Keyword(s => s.Name("Roles").IgnoreAbove(256).Norms(false).IndexOptions(IndexOptions.Docs))
                                                                                                                .Number(s => s.Name("LastLogin").Type(NumberType.Long).IgnoreMalformed())
                                                                                                                )))).ConfigureAwait(false);

            await _client.CreateIndexAsync(typeof(User.Services.UsersWithRoleHandler.UserRoles).FullName.ToLower(), i => i
                                           .Settings(s => s
                                                     .NumberOfShards(3)
                                                     .TotalShardsPerNode(3)
                                                     .NumberOfReplicas(0)
                                                     .Analysis(analysis => analysis
                                                               .TokenFilters(f => f.NGram("ngram", d => d.MinGram(3).MaxGram(4)))
                                                               .Analyzers(a => a
                                                                          .Custom("default",
                                                                                  t => t.Tokenizer("keyword").Filters(new[]
                                                                                                                      { "standard", "lowercase", "asciifolding", "kstem", "ngram" }))
                                                                          )
                                                               )
                                                     )
                                           .Mappings(mappings => mappings.Map <User.Models.User>(map =>
                                                                                                 map.Properties(props =>
                                                                                                                props.Keyword(s => s.Name("RoleId").IgnoreAbove(256).Norms(false).IndexOptions(IndexOptions.Docs))
                                                                                                                .Keyword(s => s.Name("Users").IgnoreAbove(256).Norms(false).IndexOptions(IndexOptions.Docs))
                                                                                                                )))).ConfigureAwait(false);

            this.Done = true;
            return(true);
        }
Exemple #30
0
        public async Task <bool> Initialize()
        {
            await _client.CreateIndexAsync(typeof(Buyer.Models.OrderingBuyerIndex).FullName.ToLower(), i => i
                                           .Settings(s => s
                                                     .NumberOfShards(3)
                                                     .TotalShardsPerNode(3)
                                                     .NumberOfReplicas(0)
                                                     .Analysis(analysis => analysis.AutoCompleteAnalyzers())
                                                     )
                                           .Mappings(mappings => mappings.Map <Buyer.Models.OrderingBuyerIndex>(map =>
                                                                                                                map.Properties(props =>
                                                                                                                               props.Keyword(s => s.Name(x => x.Id).IgnoreAbove(256))
                                                                                                                               .Text(s => s.Name(x => x.GivenName).Fields(x => x.AutoCompleteFields()))
                                                                                                                               .Boolean(s => s.Name(x => x.GoodStanding))
                                                                                                                               .Number(s => s.Name(x => x.TotalSpent).Type(NumberType.Long))
                                                                                                                               .Text(s => s.Name(x => x.PreferredCity).Fields(x => x.AutoCompleteFields()))
                                                                                                                               .Text(s => s.Name(x => x.PreferredState).Fields(x => x.AutoCompleteFields()))
                                                                                                                               .Text(s => s.Name(x => x.PreferredCountry).Fields(x => x.AutoCompleteFields()))
                                                                                                                               .Text(s => s.Name(x => x.PreferredZipCode).Fields(x => x.AutoCompleteFields()))
                                                                                                                               .Text(s => s.Name(x => x.PreferredPaymentCardholder).Fields(x => x.AutoCompleteFields()))
                                                                                                                               .Text(s => s.Name(x => x.PreferredPaymentMethod).Fields(x => x.AutoCompleteFields()))
                                                                                                                               .Text(s => s.Name(x => x.PreferredPaymentExpiration).Fields(x => x.AutoCompleteFields()))
                                                                                                                               )))).ConfigureAwait(false);

            await _client.CreateIndexAsync(typeof(Buyer.Entities.Address.Models.Address).FullName.ToLower(), i => i
                                           .Settings(s => s
                                                     .NumberOfShards(3)
                                                     .TotalShardsPerNode(3)
                                                     .NumberOfReplicas(0)
                                                     .Analysis(analysis => analysis.AutoCompleteAnalyzers())
                                                     )
                                           .Mappings(mappings => mappings.Map <Buyer.Entities.Address.Models.Address>(map =>
                                                                                                                      map.Properties(props =>
                                                                                                                                     props.Keyword(s => s.Name(x => x.Id).IgnoreAbove(256))
                                                                                                                                     .Keyword(s => s.Name(x => x.UserName).IgnoreAbove(256))
                                                                                                                                     .Text(s => s.Name(x => x.Alias).Fields(x => x.AutoCompleteFields()))
                                                                                                                                     .Text(s => s.Name(x => x.Street).Fields(x => x.AutoCompleteFields()))
                                                                                                                                     .Text(s => s.Name(x => x.City).Fields(x => x.AutoCompleteFields()))
                                                                                                                                     .Text(s => s.Name(x => x.State).Fields(x => x.AutoCompleteFields()))
                                                                                                                                     .Text(s => s.Name(x => x.Country).Fields(x => x.AutoCompleteFields()))
                                                                                                                                     .Text(s => s.Name(x => x.ZipCode).Fields(x => x.AutoCompleteFields()))
                                                                                                                                     )))).ConfigureAwait(false);

            await _client.CreateIndexAsync(typeof(Buyer.Entities.PaymentMethod.Models.PaymentMethod).FullName.ToLower(), i => i
                                           .Settings(s => s
                                                     .NumberOfShards(3)
                                                     .TotalShardsPerNode(3)
                                                     .NumberOfReplicas(0)
                                                     .Analysis(analysis => analysis.AutoCompleteAnalyzers())
                                                     )
                                           .Mappings(mappings => mappings.Map <Buyer.Entities.PaymentMethod.Models.PaymentMethod>(map =>
                                                                                                                                  map.Properties(props =>
                                                                                                                                                 props.Keyword(s => s.Name(x => x.Id).IgnoreAbove(256))
                                                                                                                                                 .Keyword(s => s.Name(x => x.UserName).IgnoreAbove(256))
                                                                                                                                                 .Text(s => s.Name(x => x.Alias).Fields(x => x.AutoCompleteFields()))
                                                                                                                                                 .Text(s => s.Name(x => x.CardNumber).Fields(x => x.AutoCompleteFields()))
                                                                                                                                                 .Text(s => s.Name(x => x.SecurityNumber).Fields(x => x.AutoCompleteFields()))
                                                                                                                                                 .Text(s => s.Name(x => x.CardholderName).Fields(x => x.AutoCompleteFields()))
                                                                                                                                                 .Date(s => s.Name(x => x.Expiration))
                                                                                                                                                 .Text(s => s.Name(x => x.CardType).Fields(x => x.AutoCompleteFields()))
                                                                                                                                                 )))).ConfigureAwait(false);


            await _client.CreateIndexAsync(typeof(Order.Models.OrderingOrder).FullName.ToLower(), i => i
                                           .Settings(s => s
                                                     .NumberOfShards(3)
                                                     .TotalShardsPerNode(3)
                                                     .NumberOfReplicas(0)
                                                     .Analysis(analysis => analysis.AutoCompleteAnalyzers())
                                                     )
                                           .Mappings(mappings => mappings.Map <Order.Models.OrderingOrder>(map =>
                                                                                                           map.Properties(props =>
                                                                                                                          props.Keyword(s => s.Name(x => x.Id).IgnoreAbove(256))
                                                                                                                          .Keyword(s => s.Name(x => x.UserName).IgnoreAbove(256))
                                                                                                                          .Text(s => s.Name(x => x.BuyerName).Fields(x => x.AutoCompleteFields()))
                                                                                                                          .Keyword(s => s.Name(x => x.Status).IgnoreAbove(256))
                                                                                                                          .Keyword(s => s.Name(x => x.StatusDescription).IgnoreAbove(256))
                                                                                                                          .Keyword(s => s.Name(x => x.BillingAddressId).IgnoreAbove(256))
                                                                                                                          .Text(s => s.Name(x => x.BillingAddress).Fields(x => x.AutoCompleteFields()))
                                                                                                                          .Text(s => s.Name(x => x.BillingCityState).Fields(x => x.AutoCompleteFields()))
                                                                                                                          .Text(s => s.Name(x => x.BillingZipCode).Fields(x => x.AutoCompleteFields()))
                                                                                                                          .Text(s => s.Name(x => x.BillingCountry).Fields(x => x.AutoCompleteFields()))
                                                                                                                          .Keyword(s => s.Name(x => x.ShippingAddressId).IgnoreAbove(256))
                                                                                                                          .Text(s => s.Name(x => x.ShippingAddress).Fields(x => x.AutoCompleteFields()))
                                                                                                                          .Text(s => s.Name(x => x.ShippingCityState).Fields(x => x.AutoCompleteFields()))
                                                                                                                          .Text(s => s.Name(x => x.ShippingZipCode).Fields(x => x.AutoCompleteFields()))
                                                                                                                          .Text(s => s.Name(x => x.ShippingCountry).Fields(x => x.AutoCompleteFields()))
                                                                                                                          .Keyword(s => s.Name(x => x.PaymentMethodId).IgnoreAbove(256))
                                                                                                                          .Text(s => s.Name(x => x.PaymentMethod).Fields(x => x.AutoCompleteFields()))
                                                                                                                          .Number(s => s.Name(x => x.TotalItems).Type(NumberType.Long))
                                                                                                                          .Number(s => s.Name(x => x.TotalQuantity).Type(NumberType.Long))
                                                                                                                          .Number(s => s.Name(x => x.SubTotal).Type(NumberType.Long))
                                                                                                                          .Number(s => s.Name(x => x.AdditionalFees).Type(NumberType.Long))
                                                                                                                          .Number(s => s.Name(x => x.AdditionalTaxes).Type(NumberType.Long))
                                                                                                                          .Number(s => s.Name(x => x.Total).Type(NumberType.Long))
                                                                                                                          .Date(s => s.Name(x => x.Created).Format("epoch_millis"))
                                                                                                                          .Date(s => s.Name(x => x.Updated).Format("epoch_millis"))
                                                                                                                          .Boolean(s => s.Name(x => x.Paid))
                                                                                                                          .Nested <Order.Entities.Item.Models.OrderingOrderItem>(s => s
                                                                                                                                                                                 .Name(x => x.Items)
                                                                                                                                                                                 .Properties(prop => prop
                                                                                                                                                                                             .Keyword(t => t.Name(x => x.Id).IgnoreAbove(256))
                                                                                                                                                                                             .Keyword(t => t.Name(x => x.OrderId).IgnoreAbove(256))
                                                                                                                                                                                             .Keyword(t => t.Name(x => x.ProductId).IgnoreAbove(256))
                                                                                                                                                                                             .Binary(t => t.Name(x => x.ProductPictureContents))
                                                                                                                                                                                             .Keyword(t => t.Name(x => x.ProductPictureContentType).IgnoreAbove(256))
                                                                                                                                                                                             .Text(t => t.Name(x => x.ProductName).Fields(x => x.AutoCompleteFields()))
                                                                                                                                                                                             .Text(t => t.Name(x => x.ProductDescription).Fields(x => x.AutoCompleteFields()))
                                                                                                                                                                                             .Number(t => t.Name(x => x.ProductPrice).Type(NumberType.Long))
                                                                                                                                                                                             .Number(t => t.Name(x => x.Price).Type(NumberType.Long))
                                                                                                                                                                                             .Number(t => t.Name(x => x.Quantity).Type(NumberType.Long))
                                                                                                                                                                                             .Number(t => t.Name(x => x.SubTotal).Type(NumberType.Long))
                                                                                                                                                                                             .Number(t => t.Name(x => x.AdditionalFees).Type(NumberType.Long))
                                                                                                                                                                                             .Number(t => t.Name(x => x.AdditionalTaxes).Type(NumberType.Long))
                                                                                                                                                                                             .Number(t => t.Name(x => x.Total).Type(NumberType.Long))
                                                                                                                                                                                             ))
                                                                                                                          )))).ConfigureAwait(false);

            await _client.CreateIndexAsync(typeof(Order.Models.OrderingOrderIndex).FullName.ToLower(), i => i
                                           .Settings(s => s
                                                     .NumberOfShards(3)
                                                     .TotalShardsPerNode(3)
                                                     .NumberOfReplicas(0)
                                                     .Analysis(analysis => analysis.AutoCompleteAnalyzers())
                                                     )
                                           .Mappings(mappings => mappings.Map <Order.Models.OrderingOrderIndex>(map =>
                                                                                                                map.Properties(props =>
                                                                                                                               props.Keyword(s => s.Name(x => x.Id).IgnoreAbove(256))
                                                                                                                               .Keyword(s => s.Name(x => x.UserName).IgnoreAbove(256))
                                                                                                                               .Text(s => s.Name(x => x.BuyerName).Fields(x => x.AutoCompleteFields()))
                                                                                                                               .Keyword(s => s.Name(x => x.Status).IgnoreAbove(256))
                                                                                                                               .Keyword(s => s.Name(x => x.StatusDescription).IgnoreAbove(256))
                                                                                                                               .Keyword(s => s.Name(x => x.BillingAddressId).IgnoreAbove(256))
                                                                                                                               .Text(s => s.Name(x => x.BillingAddress).Fields(x => x.AutoCompleteFields()))
                                                                                                                               .Text(s => s.Name(x => x.BillingCity).Fields(x => x.AutoCompleteFields()))
                                                                                                                               .Text(s => s.Name(x => x.BillingState).Fields(x => x.AutoCompleteFields()))
                                                                                                                               .Text(s => s.Name(x => x.BillingZipCode).Fields(x => x.AutoCompleteFields()))
                                                                                                                               .Text(s => s.Name(x => x.BillingCountry).Fields(x => x.AutoCompleteFields()))
                                                                                                                               .Keyword(s => s.Name(x => x.ShippingAddressId).IgnoreAbove(256))
                                                                                                                               .Text(s => s.Name(x => x.ShippingAddress).Fields(x => x.AutoCompleteFields()))
                                                                                                                               .Text(s => s.Name(x => x.ShippingCity).Fields(x => x.AutoCompleteFields()))
                                                                                                                               .Text(s => s.Name(x => x.ShippingState).Fields(x => x.AutoCompleteFields()))
                                                                                                                               .Text(s => s.Name(x => x.ShippingZipCode).Fields(x => x.AutoCompleteFields()))
                                                                                                                               .Text(s => s.Name(x => x.ShippingCountry).Fields(x => x.AutoCompleteFields()))
                                                                                                                               .Keyword(s => s.Name(x => x.PaymentMethodId).IgnoreAbove(256))
                                                                                                                               .Text(s => s.Name(x => x.PaymentMethod).Fields(x => x.AutoCompleteFields()))
                                                                                                                               .Number(s => s.Name(x => x.TotalItems).Type(NumberType.Long))
                                                                                                                               .Number(s => s.Name(x => x.TotalQuantity).Type(NumberType.Long))
                                                                                                                               .Number(s => s.Name(x => x.SubTotal).Type(NumberType.Long))
                                                                                                                               .Number(s => s.Name(x => x.Additional).Type(NumberType.Long))
                                                                                                                               .Number(s => s.Name(x => x.Total).Type(NumberType.Long))
                                                                                                                               .Date(s => s.Name(x => x.Created).Format("epoch_millis"))
                                                                                                                               .Date(s => s.Name(x => x.Updated).Format("epoch_millis"))
                                                                                                                               .Boolean(s => s.Name(x => x.Paid))
                                                                                                                               )))).ConfigureAwait(false);

            await _client.CreateIndexAsync(typeof(Order.Entities.Item.Models.OrderingOrderItem).FullName.ToLower(), i => i
                                           .Settings(s => s
                                                     .NumberOfShards(3)
                                                     .TotalShardsPerNode(3)
                                                     .NumberOfReplicas(0)
                                                     .Analysis(analysis => analysis.AutoCompleteAnalyzers())
                                                     )
                                           .Mappings(mappings => mappings.Map <Order.Entities.Item.Models.OrderingOrderItem>(map =>
                                                                                                                             map.Properties(props =>
                                                                                                                                            props.Keyword(s => s.Name(x => x.Id).IgnoreAbove(256))
                                                                                                                                            .Keyword(s => s.Name(x => x.OrderId).IgnoreAbove(256))
                                                                                                                                            .Keyword(s => s.Name(x => x.ProductId).IgnoreAbove(256))
                                                                                                                                            .Binary(s => s.Name(x => x.ProductPictureContents))
                                                                                                                                            .Keyword(s => s.Name(x => x.ProductPictureContentType).IgnoreAbove(256))
                                                                                                                                            .Text(s => s.Name(x => x.ProductName).Fields(x => x.AutoCompleteFields()))
                                                                                                                                            .Text(s => s.Name(x => x.ProductDescription).Fields(x => x.AutoCompleteFields()))
                                                                                                                                            .Number(s => s.Name(x => x.ProductPrice).Type(NumberType.Long))
                                                                                                                                            .Number(s => s.Name(x => x.Price).Type(NumberType.Long))
                                                                                                                                            .Number(s => s.Name(x => x.Quantity).Type(NumberType.Long))
                                                                                                                                            .Number(s => s.Name(x => x.SubTotal).Type(NumberType.Long))
                                                                                                                                            .Number(s => s.Name(x => x.AdditionalFees).Type(NumberType.Long))
                                                                                                                                            .Number(s => s.Name(x => x.AdditionalTaxes).Type(NumberType.Long))
                                                                                                                                            .Number(s => s.Name(x => x.Total).Type(NumberType.Long))
                                                                                                                                            )))).ConfigureAwait(false);

            await _client.CreateIndexAsync(typeof(Order.Models.SalesByState).FullName.ToLower(), i => i
                                           .Settings(s => s
                                                     .NumberOfShards(3)
                                                     .TotalShardsPerNode(3)
                                                     .NumberOfReplicas(0)
                                                     .Analysis(analysis => analysis.AutoCompleteAnalyzers())
                                                     )
                                           .Mappings(mappings => mappings.Map <Order.Models.SalesByState>(map =>
                                                                                                          map.Properties(props =>
                                                                                                                         props.Keyword(s => s.Name(x => x.Id).IgnoreAbove(256))
                                                                                                                         .Keyword(s => s.Name(x => x.State).IgnoreAbove(256))
                                                                                                                         .Number(s => s.Name(x => x.Relevancy).Type(NumberType.Long))
                                                                                                                         .Number(s => s.Name(x => x.Value).Type(NumberType.Long))
                                                                                                                         )))).ConfigureAwait(false);

            await _client.CreateIndexAsync(typeof(Order.Models.SalesChart).FullName.ToLower(), i => i
                                           .Settings(s => s
                                                     .NumberOfShards(3)
                                                     .TotalShardsPerNode(3)
                                                     .NumberOfReplicas(0)
                                                     .Analysis(analysis => analysis.AutoCompleteAnalyzers())
                                                     )
                                           .Mappings(mappings => mappings.Map <Order.Models.SalesChart>(map =>
                                                                                                        map.Properties(props =>
                                                                                                                       props.Keyword(s => s.Name(x => x.Id).IgnoreAbove(256))
                                                                                                                       .Keyword(s => s.Name(x => x.Label).IgnoreAbove(256))
                                                                                                                       .Number(s => s.Name(x => x.Relevancy).Type(NumberType.Long))
                                                                                                                       .Number(s => s.Name(x => x.Value).Type(NumberType.Long))
                                                                                                                       )))).ConfigureAwait(false);

            await _client.CreateIndexAsync(typeof(Order.Models.SalesWeekOverWeek).FullName.ToLower(), i => i
                                           .Settings(s => s
                                                     .NumberOfShards(3)
                                                     .TotalShardsPerNode(3)
                                                     .NumberOfReplicas(0)
                                                     .Analysis(analysis => analysis.AutoCompleteAnalyzers())
                                                     )
                                           .Mappings(mappings => mappings.Map <Order.Models.SalesWeekOverWeek>(map =>
                                                                                                               map.Properties(props =>
                                                                                                                              props.Keyword(s => s.Name(x => x.Id).IgnoreAbove(256))
                                                                                                                              .Keyword(s => s.Name(x => x.DayOfWeek).IgnoreAbove(256))
                                                                                                                              .Number(s => s.Name(x => x.Relevancy).Type(NumberType.Long))
                                                                                                                              .Number(s => s.Name(x => x.Value).Type(NumberType.Long))
                                                                                                                              )))).ConfigureAwait(false);

            this.Done = true;
            return(true);
        }