Example #1
0
        public void UsingStaticPropertyField()
        {
            Field fieldString = "name";

            /** but for expressions this is still rather involved */
            var fieldExpression = Infer.Field <Project>(p => p.Name);

            /** this can be even shortened even further using a static import.
             * Now that is much terser then our first example using the constructor!
             */
            fieldExpression = Field <Project>(p => p.Name);

            Expect("name")
            .WhenSerializing(fieldString)
            .WhenSerializing(fieldExpression);

            /** You can specify boosts in the field using a string, as well as using `Nest.Infer.Field` */
            fieldString = "name^2.1";
            fieldString.Boost.Should().Be(2.1);

            fieldExpression = Field <Project>(p => p.Name, 2.1);
            fieldExpression.Boost.Should().Be(2.1);

            Expect("name^2.1")
            .WhenSerializing(fieldString)
            .WhenSerializing(fieldExpression);
        }
Example #2
0
    public Tuple <string, List <BoardGame> > QueryData_MinPlayTime(string query)
    {
        _elasticClient.Flush("boardgames");

        var queryContainer = new QueryContainer();

        queryContainer &= new MatchAllQuery();

        var aggregation = new MinAggregation("min_playing_time_aggregation",
                                             Infer.Field <BoardGame>(p => p.PlayingTime));

        var searchRequest = new SearchRequest("boardgames", typeof(BoardGame))
        {
            Query        = queryContainer,
            Aggregations = aggregation
        };

        var searchResponse = _elasticClient.Search <BoardGame>(searchRequest);

        var minPlayingTime = searchResponse.Aggregations.Min("min_playing_time_aggregation");

        return(new Tuple <string, List <BoardGame> >(
                   searchResponse.DebugInformation,
                   searchResponse.Documents.ToList()
                   ));
    }
 protected RollupSearchRequest RollupSearchInitializer(string index) => new RollupSearchRequest(CreateRollupSearchIndices(index))
 {
     Size         = 0,
     Query        = new MatchAllQuery(),
     Aggregations = new MaxAggregation("max_temp", Infer.Field <Log>(p => p.Temperature)) &&
                    new AverageAggregation("avg_temp", Infer.Field <Log>(p => p.Temperature))
 };
 protected CreateRollupJobRequest CreateInitializer(string role) => new CreateRollupJobRequest(CreateRollupName(role))
 {
     PageSize     = 1000,
     IndexPattern = TimeSeriesSeeder.IndicesWildCard,
     RollupIndex  = CreateRollupName(role),
     Cron         = CronPeriod,
     Groups       = new RollupGroupings
     {
         DateHistogram = new DateHistogramRollupGrouping
         {
             Field    = Infer.Field <Log>(p => p.Timestamp),
             Interval = TimeSpan.FromHours(1)
         },
         Terms = new TermsRollupGrouping
         {
             Fields = Infer.Field <Log>(p => p.Section).And <Log>(p => p.Tag)
         },
         Histogram = new HistogramRollupGrouping
         {
             Fields   = Infer.Field <Log>(p => p.Load).And <Log>(p => p.NetIn).And <Log>(p => p.NetOut),
             Interval = 5
         }
     },
     Metrics = new List <IRollupFieldMetric>
     {
         new RollupFieldMetric
         {
             Field   = Infer.Field <Log>(p => p.Temperature),
             Metrics = new[] { RollupMetric.Average, RollupMetric.Min, RollupMetric.Max }
         },
     }
 };
        public SearchResult <Post> SearchByCategory(string query, IEnumerable <string> tags, int page = 1,
                                                    int pageSize = 10)
        {
            var fieldQuery = new MultiMatchQuery
            {
                Query  = query,
                Fields = new[]
                {
                    Infer.Field <Post>(p => p.Title),
                    Infer.Field <Post>(p => p.Body),
                    Infer.Field <Post>(p => p.Tags)
                },
                Fuzziness = Fuzziness.EditDistance(1)
            };

            var categoryFilter = new BoolQuery
            {
                Must = new QueryContainer[]
                {
                    new TermsQuery
                    {
                        Field = Infer.Field <Post>(p => p.Tags),
                        Terms = tags
                    }
                }
            };

            var searchRequest = new SearchRequest
            {
                From  = page - 1,
                Size  = pageSize,
                Query = new BoolQuery
                {
                    Must = new QueryContainer[]
                    {
                        fieldQuery
                    },
                    Filter = new QueryContainer[]
                    {
                        categoryFilter
                    }
                },
                Aggregations = new TermsAggregation("by_tags")
                {
                    Field = Infer.Field <Post>(p => p.Tags),
                    Size  = 10
                }
            };

            var result = _client.Search <Post>(searchRequest);

            return(new SearchResult <Post>
            {
                Total = (int)result.Total,
                Page = page,
                Results = result.Hits.Select(hit => new SearchResultItem <Post>(hit.Source, hit.Score)),
                ElapsedMilliseconds = result.Took,
                AggregationsByTags = result.Aggs.Terms("by_tags").Buckets.ToDictionary(x => x.Key, y => y.DocCount.GetValueOrDefault(0))
            });
        }
Example #6
0
        public void UsingStaticPropertyField()
        {
            Field fieldString = "name";

            /** but for expressions this is still rather involved */
            var fieldExpression = Infer.Field <Project>(p => p.Name);

            /** Using static imports in c# 6 this can be even shortened:
             *      using static Nest.Static;
             */
            fieldExpression = Field <Project>(p => p.Name);
            /** Now this is much much terser then our first example using the constructor! */

            Expect("name")
            .WhenSerializing(fieldString)
            .WhenSerializing(fieldExpression);

            fieldString = "name^2.1";
            fieldString.Boost.Should().Be(2.1);
            fieldExpression = Field <Project>(p => p.Name, 2.1);
            /** Now this is much much terser then our first example using the constructor! */

            Expect("name^2.1")
            .WhenSerializing(fieldString)
            .WhenSerializing(fieldExpression);
        }
 private static void ExcludeUnwantedFields(SearchRequest <ElasticArchiveRecord> searchRequest)
 {
     // Exclude content from primarydata.
     searchRequest.Source = new SourceFilter {
         Excludes = Infer.Fields("all", "primaryData.items.content")
     };
 }
        public IEnumerable <string> Autocomplete(string query)
        {
            var searchRequest = new SearchRequest
            {
                Suggest = new SuggestContainer
                {
                    {
                        "tag-suggestions",
                        new SuggestBucket
                        {
                            Prefix     = query,
                            Completion = new CompletionSuggester
                            {
                                Field = Infer.Field <Post>(p => p.Suggest),
                                Size  = 1
                            }
                        }
                    }
                }
            };

            var result = _client.Search <Post>(searchRequest);

            return(result.Suggest["tag-suggestions"].SelectMany(x => x.Options).Select(y => y.Text));
        }
Example #9
0
        [U] public async Task Urls()
        {
            var project = new Project {
                Name = "NEST"
            };
            var routing = Infer.Route(project);

            await POST("/project/_explain/NEST?routing=NEST")
            .Fluent(c => c.Explain <Project>(project, e => e.Routing(routing).Query(q => q.MatchAll())))
            .Request(c => c.Explain <Project>(new ExplainRequest <Project>(project)
            {
                Routing = routing
            }))
            .FluentAsync(c => c.ExplainAsync <Project>(project, e => e.Routing(routing).Query(q => q.MatchAll())))
            .RequestAsync(c => c.ExplainAsync <Project>(new ExplainRequest <Project>(project)
            {
                Routing = routing
            }))
            ;

            await POST("/project/_explain/NEST")
            .Fluent(c => c.Explain <Project>("NEST", e => e.Query(q => q.MatchAll())))
            .Request(c => c.Explain <Project>(new ExplainRequest <Project>("project", "NEST")))
            .FluentAsync(c => c.ExplainAsync <Project>("NEST", e => e.Query(q => q.MatchAll())))
            .RequestAsync(c => c.ExplainAsync <Project>(new ExplainRequest <Project>("NEST")))
            ;
        }
Example #10
0
        private static void LoadMovieGroups(IElasticClient elasticClient)
        {
            var searchRequest = new SearchRequest <MovieSearchItem>
            {
                Size         = 0,
                Aggregations = new TermsAggregation("by_tags")
                {
                    Field = Infer.Field <MovieSearchItem>(m => m.Tags)
                } && new TermsAggregation("by_release_year")
                {
                    Field = Infer.Field <MovieSearchItem>(m => m.ReleaseYear)
                }
            };

            Console.WriteLine("Query to run:");
            Console.WriteLine(GetQuery(elasticClient, searchRequest));

            var searchResult = elasticClient.Search <MovieSearchItem>(searchRequest);
            var tagsAgg      = searchResult.Aggs.Terms("by_tags");
            var yearsAgg     = searchResult.Aggs.Terms("by_release_year");

            Console.WriteLine("tags:");
            foreach (var tagsBucket in tagsAgg.Buckets)
            {
                Console.WriteLine($"{tagsBucket.Key}-{tagsBucket.DocCount}");
            }

            Console.WriteLine("tags:");
            foreach (var yearsBucket in yearsAgg.Buckets)
            {
                Console.WriteLine($"{yearsBucket.Key}-{yearsBucket.DocCount}");
            }
        }
        public async Task <DeliveryStore> GetDeliveryStoreByFSA(string fsa)
        {
            var searchRequest = new SearchRequest <DeliveryStore>()
            {
                Query = new MatchQuery
                {
                    Field = Infer.Field <DeliveryStore>(o => o.FSA),
                    Query = fsa
                }
            };

            var searchResponse = await _elasticClient.SearchAsync <DeliveryStore>(searchRequest);

            if (searchResponse.Documents.Count > 0)
            {
                var           storeResponse = searchResponse.Documents.FirstOrDefault();
                DeliveryStore ds            = new()
                {
                    Id                 = storeResponse.Id,
                    FSA                = storeResponse.FSA,
                    StoreNumber        = storeResponse.StoreNumber,
                    DeliveryVendorId   = storeResponse.DeliveryVendorId,
                    DeliveryVendorName = storeResponse.DeliveryVendorName,
                    DeliveryFeePLU     = storeResponse.DeliveryFeePLU,
                    DeliveryFeePromo   = storeResponse.DeliveryFeePromo,
                    ClientCode         = storeResponse.ClientCode
                };
                return(ds);
            }
            else
            {
                return(null);
            }
        }
 public EventStackFilterQueryBuilder(IStackRepository stackRepository, ILoggerFactory loggerFactory)
 {
     _stackRepository                  = stackRepository;
     _logger                           = loggerFactory.CreateLogger <EventStackFilterQueryBuilder>();
     _inferredEventDateField           = Infer.Field <PersistentEvent>(f => f.Date);
     _inferredStackLastOccurrenceField = Infer.Field <Stack>(f => f.LastOccurrence);
 }
        public void UsingStaticPropertyField()
        {
            Field fieldString = "name";

            /** but for expressions this is still rather involved */
            var fieldExpression = Infer.Field <Project>(p => p.Name);

            /** this can be even shortened even further using a https://msdn.microsoft.com/en-us/library/sf0df423.aspx#Anchor_0[static import in C# 6] i.e.
             *      `using static Nest.Infer;`
             */
            fieldExpression = Field <Project>(p => p.Name);
            /** Now that is much terser then our first example using the constructor! */

            Expect("name")
            .WhenSerializing(fieldString)
            .WhenSerializing(fieldExpression);

            /** You can specify boosts in the field using a string */
            fieldString = "name^2.1";
            fieldString.Boost.Should().Be(2.1);

            /** As well as using `Nest.Infer.Field` */
            fieldExpression = Field <Project>(p => p.Name, 2.1);
            Expect("name^2.1")
            .WhenSerializing(fieldString)
            .WhenSerializing(fieldExpression);
        }
Example #14
0
        [U] public void TypedEq()
        {
            Field t1 = Infer.Field <Project>(p => p.Name), t2 = Infer.Field <Project>(p => p.Name);

            (t1 == t2).ShouldBeTrue(t2);
            t1.Should().Be(t2);
        }
Example #15
0
 [U] public void TermsQuery() =>
 Serializes(new TermsQuery {
     Field = Infer.Field <Project>(p => p.Name), Terms = new object[] { SomeEnum.AnotherValue }
 },
            new { name = new[] { 1 } },
            new { name = new[] { "different" } }
            );
Example #16
0
        protected override void IntegrationSetup(IElasticClient client, CallUniqueValues values)
        {
            foreach (var index in values.Values)
            {
                this.Client.CreateIndex(index, c => c
                                        .Settings(settings => settings
                                                  .Analysis(Seeder.ProjectAnalysisSettings)
                                                  )
                                        .Mappings(m => m
                                                  .Map <Project>(mm => mm.AutoMap()
                                                                 .Properties(Seeder.ProjectProperties)
                                                                 )
                                                  .Map <PercolatedQuery>(mm => mm.AutoMap()
                                                                         .Properties(Seeder.PercolatedQueryProperties)
                                                                         )
                                                  )
                                        );

                this.Client.Index(new PercolatedQuery
                {
                    Id    = PercolatorId,
                    Query = new QueryContainer(new MatchQuery
                    {
                        Field = Infer.Field <Project>(f => f.LeadDeveloper.FirstName),
                        Query = "Martijn"
                    })
                }, d => d.Index(index));

                this.Client.Refresh(index);
            }
        }
Example #17
0
        [U] public void TypedNotEq()
        {
            Field t1 = Infer.Field <Developer>(p => p.Id), t2 = Infer.Field <CommitActivity>(p => p.Id);

            (t1 != t2).ShouldBeTrue(t2);
            t1.Should().NotBe(t2);
        }
        public void StoredFields()
        {
            /**
             * When storing fields in this manner, the individual field values to return can be specified using
             * `.StoredFields` on the search request
             */
            var searchResponse = _client.Search <Project>(s => s
                                                          .StoredFields(sf => sf
                                                                        .Fields(
                                                                            f => f.Name,
                                                                            f => f.StartedOn,
                                                                            f => f.Branches
                                                                            )
                                                                        )
                                                          .Query(q => q
                                                                 .MatchAll()
                                                                 )
                                                          );

            /**
             * And retrieving them is possible using `.Fields` on the response
             */
            foreach (var fieldValues in searchResponse.Fields)
            {
                var document = new                 // <1> Construct a partial document as an anonymous type from the stored fields requested
                {
                    Name      = fieldValues.ValueOf <Project, string>(p => p.Name),
                    StartedOn = fieldValues.Value <DateTime>(Infer.Field <Project>(p => p.StartedOn)),
                    Branches  = fieldValues.Values <Project, string>(p => p.Branches.First())
                };
            }
        }
Example #19
0
    public Tuple <string, List <BoardGame> > QueryData_Buckets(string query)
    {
        _elasticClient.Flush("boardgames");

        var queryContainer = new QueryContainer();

        queryContainer &= new MatchAllQuery();

        var aggregation = new TermsAggregation("category_aggregation")
        {
            Field = Infer.Field <BoardGame>(p => p.Category),
        };

        var searchRequest = new SearchRequest("boardgames", typeof(BoardGame))
        {
            Query        = queryContainer,
            Aggregations = aggregation
        };

        var searchResponse = _elasticClient.Search <BoardGame>(searchRequest);

        var categories = searchResponse.Aggregations.Terms("category_aggregation").Buckets;

        return(new Tuple <string, List <BoardGame> >(
                   searchResponse.DebugInformation,
                   searchResponse.Documents.ToList()
                   ));
    }
Example #20
0
        public async Task <IPagedResponse <NewsReadModel> > SearchAsync([FromQuery] NewsSearchQuery searchQuery, CancellationToken cancellationToken)
        {
            IPagedResponse <NewsReadModel> response = null;
            await _elasticClient.Indices.FlushAsync(indexName, d => d.RequestConfiguration(c => c.AllowedStatusCodes((int)HttpStatusCode.NotFound)), cancellationToken);

            await _elasticClient.Indices.RefreshAsync(indexName, d => d.RequestConfiguration(c => c.AllowedStatusCodes((int)HttpStatusCode.NotFound)), cancellationToken);

            SearchRequest searchRequest = new SearchRequest <NewsReadModel>(indexName)
            {
                Query = new BoolQuery()
                {
                    Should = new QueryContainer[]
                    {
                        new MatchQuery()
                        {
                            Field = Infer.Field <NewsReadModel>(f => f.Title),
                            Query = searchQuery.Title,
                            Boost = 1.1
                        },
                        new MatchQuery()
                        {
                            Field = Infer.Field <NewsReadModel>(f => f.SubTitle),
                            Query = searchQuery.SubTitle,
                        }
                    },
                    Filter = new QueryContainer[]
                    {
                        new TermQuery()
                        {
                            Field = Infer.Field <NewsReadModel>(f => f.NCategory),
                            Value = searchQuery.Category,
                        },
                        new TermQuery()
                        {
                            Field = Infer.Field <NewsReadModel>(f => f.Country),
                            Value = searchQuery.Country,
                        },
                        new MatchQuery()
                        {
                            Field = Infer.Field <NewsReadModel>(f => f.PortalName),
                            Query = searchQuery.Portal,
                        }
                    }
                }
            };

            var record = await _elasticClient.SearchAsync <NewsReadModel>(searchRequest, cancellationToken);

            if (record?.Documents?.Count > 0)
            {
                response = new PagedResponse <NewsReadModel>()
                {
                    Records    = record.Documents.ToList(),
                    TotalCount = record.Total
                };
            }

            return(response);
        }
        public const string ParamTake              = "size"; // Do not change (ELS reserved)

        public static void Rebuild()
        {
            var request = new SearchRequest
            {
                Query = new FunctionScoreQuery
                {
                    Functions = GetQueryFunctions(),
                    ScoreMode = FunctionScoreMode.Multiply,
                    Query     = new BoolQuery
                    {
                        Filter = GetQueryFilters(),
                        Must   = new List <QueryContainer>
                        {
                            new MultiMatchQuery
                            {
                                Type = TextQueryType.MostFields,
                                MinimumShouldMatch = MinimumShouldMatch.Percentage(80),
                                Query  = $"{{{{{ParamQuery}}}}}",
                                Fields = GetQueryFields()
                            }
                        },
                        MustNot = new List <QueryContainer>
                        {
                            // Exclude unpublished documents
                            new DateRangeQuery
                            {
                                LessThanOrEqualTo = DateMath.Now,
                                Field             = Infer.Field <ElasticEpiDocument>(e => e.StopPublish)
                            },
                            // Excluded types
                            new MatchQuery
                            {
                                Field          = Infer.Field <ElasticEpiDocument>(e => e.TypeName),
                                Query          = $"{{{{{ParamExcludedTypeNames}}}}}",
                                ZeroTermsQuery = ZeroTermsQuery.None
                            },
                            // Excluded ids
                            new MatchQuery
                            {
                                Field          = Infer.Field <ElasticEpiDocument>(e => e.ContentGuid),
                                Query          = $"{{{{{ParamExcludedIds}}}}}",
                                ZeroTermsQuery = ZeroTermsQuery.None
                            }
                        }
                    }
                }
            };

            var requestString = ElasticEpiClient.Current.Get().Serializer.SerializeToString(request);
            var jsonObject    = JObject.Parse(requestString);

            jsonObject.Add(ParamSkip, "{{from}}{{^from}}0{{/from}}");
            jsonObject.Add(ParamTake, "{{size}}{{^size}}10{{/size}}");

            requestString = ElasticEpiClient.Current.Get().Serializer.SerializeToString(jsonObject);

            ElasticEpiClient.Current.Get()
            .PutSearchTemplate(new PutSearchTemplateDescriptor(Name).Template(requestString));
        }
        [U] public void TypeName()
        {
            TypeName fromString = "index-1";
            var      fromType   = Infer.Type <Project>();

            DebugFor(fromString).Should().Be("index-1");
            DebugFor(fromType).Should().Be("TypeName for typeof: Project");
        }
Example #23
0
        protected override void ConfigureQueryParser(ElasticQueryParserConfiguration config)
        {
            string dateFixedFieldName = Configuration.Client.Infer.PropertyName(Infer.Property <Stack>(f => f.DateFixed));

            config
            .SetDefaultFields(new[] { "id", Alias.Title, Alias.Description, Alias.Tags, Alias.References })
            .AddVisitor(new StackDateFixedQueryVisitor(dateFixedFieldName));
        }
        [U] public void FieldsDebug()
        {
            Nest.Fields fromString = "field1, field2";
            Nest.Fields multiple   = Infer.Field("somefield").And <Project>(p => p.Description, 12);

            DebugFor(fromString).Should().Be($"Count: 2 [(1: field1),(2: field2)]");
            DebugFor(multiple).Should().Be($"Count: 2 [(1: somefield),(2: p => p.Description^12 typeof: {nameof(Project)})]");
        }
Example #25
0
        public static void Check(IElasticClient client, string index)
        {
            var indices  = Infer.Indices(index);
            var response = client.Indices.Refresh(indices);
            var search   = client.Search <Base>(c => c.Size(1).Index(index));

            Console.WriteLine($"The index has {search.Total} logs");
            Console.WriteLine($"Last indexed message: {search.Documents.Last().Message}");
        }
        private Func <QueryContainerDescriptor <BusinessElasticModel>, QueryContainer> TimeRange()
        {
            Func <QueryContainerDescriptor <BusinessElasticModel>, QueryContainer> timeFilter = null;
            var now  = DateTime.Now;
            var time = now.TimeOfDay;

            Field openingHourDay = null;
            Field closingHourDay = null;

            switch (now.DayOfWeek)
            {
            case DayOfWeek.Monday:
                openingHourDay = Infer.Field <BusinessElasticModel>(p => p.OpeningHours.OpeningHourMonday);
                closingHourDay = Infer.Field <BusinessElasticModel>(p => p.OpeningHours.ClosingHourMonday);
                break;

            case DayOfWeek.Tuesday:
                openingHourDay = Infer.Field <BusinessElasticModel>(p => p.OpeningHours.OpeningHourTuesday);
                closingHourDay = Infer.Field <BusinessElasticModel>(p => p.OpeningHours.ClosingHourTuesday);
                break;

            case DayOfWeek.Wednesday:
                openingHourDay = Infer.Field <BusinessElasticModel>(p => p.OpeningHours.OpeningHourWednesday);
                closingHourDay = Infer.Field <BusinessElasticModel>(p => p.OpeningHours.ClosingHourWednesday);
                break;

            case DayOfWeek.Thursday:
                openingHourDay = Infer.Field <BusinessElasticModel>(p => p.OpeningHours.OpeningHourThursday);
                closingHourDay = Infer.Field <BusinessElasticModel>(p => p.OpeningHours.ClosingHourThursday);
                break;

            case DayOfWeek.Friday:
                openingHourDay = Infer.Field <BusinessElasticModel>(p => p.OpeningHours.OpeningHourFriday);
                closingHourDay = Infer.Field <BusinessElasticModel>(p => p.OpeningHours.ClosingHourFriday);
                break;

            case DayOfWeek.Saturday:
                openingHourDay = Infer.Field <BusinessElasticModel>(p => p.OpeningHours.OpeningHourSaturday);
                closingHourDay = Infer.Field <BusinessElasticModel>(p => p.OpeningHours.ClosingHourSaturday);
                break;

            case DayOfWeek.Sunday:
                openingHourDay = Infer.Field <BusinessElasticModel>(p => p.OpeningHours.OpeningHourSunday);
                closingHourDay = Infer.Field <BusinessElasticModel>(p => p.OpeningHours.ClosingHourSunday);
                break;
            }

            if (openingHourDay != null && closingHourDay != null)
            {
                timeFilter = fq =>
                             (fq.LongRange(d => d.Field(openingHourDay).LessThanOrEquals(time.Ticks)) &&
                              fq.LongRange(d => d.Field(closingHourDay).GreaterThanOrEquals(time.Ticks))) ||
                             (fq.Terms(t => t.Field(f => f.OpeningHours.AlwaysOpen).Terms(true)) ||
                              fq.Terms(t => t.Field(f => f.OpeningHours.HideOpeningHours).Terms(true)));
            }
            return(timeFilter);
        }
Example #27
0
        public void ReversSearchingTest()
        {
            Console.WriteLine($"Try create index:'{this.Index}'");
            CreatePercolatorIndex(this.Index);
            Console.WriteLine($"Index created:'{this.IndexExists(this.Index)}'");

            Console.WriteLine($"Try add to index document");
            var result = this.AddToIndex(new OfferQuery {
                Id = "1", Query = new MatchQuery
                {
                    Field = Infer.Field <Employee>(entry => entry.Skills),
                    Query = "skill"
                }
            }, this.Index);

            if (!result.IsValid)
            {
                Console.WriteLine($"Error: {result.DebugInformation}");
            }

            Console.WriteLine($"Try search");
            var search = Search(new Employee {
                Skills = new List <string> {
                    "skill"
                }
            });

            if (!search.IsValid)
            {
                Console.WriteLine($"Error: {result.DebugInformation}");
            }

            foreach (var doc in search.Documents)
            {
                Console.WriteLine($"Doc Id: {doc.Id}");
            }

            Console.WriteLine($"Try search");
            search = Search(new Employee {
                Skills = new List <string> {
                    "skin"
                }
            });
            if (!search.IsValid)
            {
                Console.WriteLine($"Error: {result.DebugInformation}");
            }

            foreach (var doc in search.Documents)
            {
                Console.WriteLine($"Doc Id: {doc.Id}");
            }

            Console.WriteLine($"Try remove index:'{this.Index}'");
            this.RemoveIndex(this.Index);
            Console.WriteLine($"Index removed:'{!this.IndexExists(this.Index)}'");
        }
Example #28
0
 public EventStackFilterQueryBuilder(IStackRepository stackRepository, ICacheClient cacheClient, ILoggerFactory loggerFactory)
 {
     _stackRepository                  = stackRepository;
     _cacheClient                      = new ScopedCacheClient(cacheClient, "stack-filter");
     _logger                           = loggerFactory.CreateLogger <EventStackFilterQueryBuilder>();
     _inferredEventDateField           = Infer.Field <PersistentEvent>(f => f.Date);
     _inferredStackLastOccurrenceField = Infer.Field <Stack>(f => f.LastOccurrence);
     _eventStackFilter                 = new EventStackFilter();
 }
        [U] public void PropertyName()
        {
            var          fieldFromString = new PropertyName("name");
            var          fieldFromExpressionWithBoost = Infer.Property <Project>(p => p.Name);
            PropertyName propertyInfoField            = typeof(Project).GetProperty(nameof(Project.Name));

            DebugFor(fieldFromString).Should().Be("name");
            DebugFor(fieldFromExpressionWithBoost).Should().Be("p => p.Name typeof: Project");
            DebugFor(propertyInfoField).Should().Be("PropertyInfo: Name typeof: Project");
        }
        [U] public void Field()
        {
            var fieldFromString = new Field("name^2");
            var fieldFromExpressionWithBoost = Infer.Field <Project>(p => p.Name, 14);
            var propertyInfoField            = Infer.Field(typeof(Project).GetProperty(nameof(Project.Name)));

            DebugFor(fieldFromString).Should().Be("name^2");
            DebugFor(fieldFromExpressionWithBoost).Should().Be("p => p.Name^14 typeof: Project");
            DebugFor(propertyInfoField).Should().Be("PropertyInfo: Name typeof: Project");
        }