Example #1
0
        public void Export_ReturnsValidJson()
        {
            var query = new ConjunctionQuery(
                new TermQuery("hotel").Field("type")
                );

            var result = query.Export().ToString(Formatting.None);

            var expected = JsonConvert.SerializeObject(new
            {
                query = new
                {
                    boost     = 0.0,
                    conjuncts = new[]
                    {
                        new
                        {
                            query = new
                            {
                                term          = "hotel",
                                boost         = 0.0,
                                field         = "type",
                                prefix_length = 0,
                                fuzziness     = 0
                            }
                        }
                    }
                }
            }, Formatting.None);

            Assert.AreEqual(expected, result);
        }
        public void Export_ReturnsValidJson()
        {
            var query = new ConjunctionQuery(
                new TermQuery("hotel").Field("type")
            );

            var result = query.Export().ToString(Formatting.None);

            var expected = JsonConvert.SerializeObject(new
            {
                query = new
                {
                    boost = 0.0,
                    conjuncts = new[]
                    {
                        new
                        {
                            query = new
                            {
                                term = "hotel",
                                boost = 0.0,
                                field = "type",
                                prefix_length = 0,
                                fuzziness = 0
                            }
                        }
                    }
                }
            }, Formatting.None);

            Assert.AreEqual(expected, result);
        }
Example #3
0
        public async Task <List <User> > FtsListActiveUsersAsync(string firstName, bool enabled, string countryCode, int limit, int skip)
        {
            // Allows a match with a Levenshtein (Edit) Distance of 1.
            var firstNameFuzzy = new MatchQuery(firstName).Fuzziness(1).Field("firstName");

            // This is the exact match for the term.
            var firstNameSimple = new MatchQuery(firstName).Field("firstName");

            //Disjunction queries are similar to "OR" operators in SQL
            var nameQuery = new DisjunctionQuery(firstNameSimple, firstNameFuzzy);

            var isEnabled     = new BooleanFieldQuery(enabled).Field("enabled");
            var countryFilter = new MatchQuery(countryCode).Field("countryCode");

            // Conjunction queries are similar to "AND" operators in SQL
            var conj = new ConjunctionQuery(nameQuery, isEnabled, countryFilter);

            var searchQuery = new SearchQuery();

            // Indicate the fields we'd like returned in the search results.
            searchQuery.Fields("id", "tenantId", "firstName", "lastName", "userName", "enabled");

            // Assign the FTS index we've created.
            searchQuery.Index = "user_index";

            // Assign our combined query.
            searchQuery.Query = conj;
            searchQuery.Skip(skip);
            searchQuery.Limit(limit);

            var result = await _bucket.QueryAsync(searchQuery);

            var users = new List <User>();

            if (result != null && result.Success)
            {
                foreach (var hit in result.Hits)
                {
                    var user = new User
                    {
                        Id        = hit.Id,
                        TenantId  = int.Parse(hit.Fields["tenantId"].ToString()),
                        FirstName = hit.Fields["firstName"],
                        LastName  = hit.Fields["lastName"],
                        UserName  = hit.Fields["userName"],
                        Enabled   = hit.Fields["enabled"]
                    };

                    users.Add(user);
                }
            }

            return(users);
        }
        public async Task <IEnumerable <GetUpcomingEventsQueryResult> > GetUpcomingEvents(GetUpcomingEventsQuery getUpcomingEventsQuery)
        {
            var geoDistanceQuery = new GeoDistanceQuery();

            geoDistanceQuery.Field("location");
            geoDistanceQuery.Latitude(getUpcomingEventsQuery.Latitude);
            geoDistanceQuery.Longitude(getUpcomingEventsQuery.Longitude);
            geoDistanceQuery.Distance($"{getUpcomingEventsQuery.Radius}km");

            var statusMatchQuery = new MatchQuery(EventStatuses.ACTIVE);

            statusMatchQuery.Field("status");

            var conjunctionQuery = new ConjunctionQuery(geoDistanceQuery, statusMatchQuery);

            if (!string.IsNullOrEmpty(getUpcomingEventsQuery.Keywords))
            {
                var subjectMatchQuery = new MatchQuery(getUpcomingEventsQuery.Keywords).Fuzziness(1);

                conjunctionQuery.And(subjectMatchQuery);
            }

            var searchParams = new SearchParams()
                               .Fields("*")
                               .Limit(10)
                               .Timeout(TimeSpan.FromMilliseconds(10000));

            var searchQuery = new SearchQuery
            {
                Query        = conjunctionQuery,
                Index        = "idx_geo_events",
                SearchParams = searchParams
            };

            var queryResult = await _eventsBucket.QueryAsync(searchQuery);

            var result = new List <GetUpcomingEventsQueryResult>();

            foreach (var hit in queryResult.Hits)
            {
                result.Add(new GetUpcomingEventsQueryResult
                {
                    EventId     = Guid.Parse(hit.Id),
                    Subject     = hit.Fields["subject"],
                    UrlKey      = hit.Fields["urlKey"],
                    Description = hit.Fields["description"],
                    Date        = DateTimeOffset.Parse(hit.Fields["date"].ToString())
                });
            }

            return(result);
        }
Example #5
0
        // end::query[]

        // tag::FtsListActiveUsers[]
        public List <User> FtsListActiveUsers(string firstName, bool enabled, string countryCode, int limit, int skip)
        {
            // tag::fuzzy[]
            var firstNameFuzzy  = new MatchQuery(firstName).Fuzziness(1).Field("firstName");
            var firstNameSimple = new MatchQuery(firstName).Field("firstName");
            var nameQuery       = new DisjunctionQuery(firstNameSimple, firstNameFuzzy);
            // end::fuzzy[]

            // tag::filter[]
            var isEnabled     = new BooleanFieldQuery(enabled).Field("enabled");
            var countryFilter = new MatchQuery(countryCode).Field("countryCode");
            // end::filter[]

            // tag::conj[]
            var conj = new ConjunctionQuery(nameQuery, isEnabled, countryFilter);
            // end::conj[]

            // tag::result[]
            var searchQuery = new SearchQuery();

            searchQuery.Fields("id", "tenantId", "firstName", "lastName", "userName");
            searchQuery.Index = "user_index";
            searchQuery.Query = conj;
            searchQuery.Skip(skip);
            searchQuery.Limit(limit);

            var result = _bucket.Query(searchQuery);
            var users  = new List <User>();

            if (result != null && !result.Errors.Any())
            {
                foreach (var hit in result.Hits)
                {
                    var user = new User();
                    user.Id        = hit.Id;
                    user.TenantId  = int.Parse(hit.Fields["tenantId"].ToString());
                    user.FirstName = hit.Fields["firstName"];
                    user.LastName  = hit.Fields["lastName"];
                    user.UserName  = hit.Fields["userName"];
                    users.Add(user);
                }
            }

            return(users);
            // end::result[]
        }
Example #6
0
        public async Task <List <User> > FtsListActiveUsersAsync(string firstName, bool enabled, string countryCode, int limit, int skip)
        {
            var firstNameFuzzy  = new MatchQuery(firstName).Fuzziness(1).Field("firstName");
            var firstNameSimple = new MatchQuery(firstName).Field("firstName");
            var nameQuery       = new DisjunctionQuery(firstNameSimple, firstNameFuzzy);

            var isEnabled     = new BooleanFieldQuery(enabled).Field("enabled");
            var countryFilter = new MatchQuery(countryCode).Field("countryCode");

            var conj = new ConjunctionQuery(nameQuery, isEnabled, countryFilter);

            var searchQuery = new SearchQuery();

            searchQuery.Fields("id", "tenantId", "firstName", "lastName", "userName");
            searchQuery.Index = "user_index";
            searchQuery.Query = conj;
            searchQuery.Skip(skip);
            searchQuery.Limit(limit);

            var result = await _bucket.QueryAsync(searchQuery);

            var users = new List <User>();

            if (result != null && result.Success)
            {
                foreach (var hit in result.Hits)
                {
                    var user = new User
                    {
                        Id        = hit.Id,
                        TenantId  = int.Parse(hit.Fields["tenantId"].ToString()),
                        FirstName = hit.Fields["firstName"],
                        LastName  = hit.Fields["lastName"],
                        UserName  = hit.Fields["userName"]
                    };

                    users.Add(user);
                }
            }

            return(users);
        }
        public void Export_ReturnsValidJson()
        {
            var query = new ConjunctionQuery(
                new TermQuery("hotel").Field("type")
                );

            var result = query.Export().ToString(Formatting.None);

            var expected = JsonConvert.SerializeObject(new
            {
                conjuncts = new[]
                {
                    new
                    {
                        term  = "hotel",
                        field = "type"
                    }
                }
            }, Formatting.None);

            Assert.Equal(expected, result);
        }
        public void Boost_WhenBoostIsLessThanZero_ThrowsArgumentOutOfRangeException()
        {
            var query = new ConjunctionQuery();

            Assert.Throws <ArgumentOutOfRangeException>(() => query.Boost(-.1));
        }
        public void Boost_ReturnsConjunctionQuery()
        {
            var query = new ConjunctionQuery().Boost(2.2);

            Assert.IsType <ConjunctionQuery> (query);
        }
        public void Boost_WhenBoostIsLessThanZero_ThrowsArgumentOutOfRangeException()
        {
            var query = new ConjunctionQuery();

            Assert.Throws<ArgumentOutOfRangeException>(() => query.Boost(-.1));
        }
        public void Boost_ReturnsConjunctionQuery()
        {
            var query = new ConjunctionQuery().Boost(2.2);

            Assert.IsInstanceOf<ConjunctionQuery> (query);
        }
Example #12
0
        public HttpResponseMessage FindHotel(string description = null, string location = null)
        {
            var query = new ConjunctionQuery(
                new TermQuery("hotel").Field("type")
                );

            if (!string.IsNullOrEmpty(description) && description != "*")
            {
                query.And(new DisjunctionQuery(
                              new PhraseQuery(description).Field("name"),
                              new PhraseQuery(description).Field("description")
                              ));
            }

            if (!string.IsNullOrEmpty(location) && location != "*")
            {
                query.And(new DisjunctionQuery(
                              new PhraseQuery(location).Field("address"),
                              new PhraseQuery(location).Field("city"),
                              new PhraseQuery(location).Field("state"),
                              new PhraseQuery(location).Field("country")
                              ));
            }

            var search = new SearchQuery();

            search.Index = "hotel";
            search.Query = query;
            search.Limit(100);

            var queryJson = query.Export().ToString(Formatting.None);
            var hotels    = new List <dynamic>();

            var result = _bucket.Query(search);

            foreach (var row in result)
            {
                var fragment = _bucket.LookupIn <dynamic>(row.Id)
                               .Get("name")
                               .Get("description")
                               .Get("address")
                               .Get("city")
                               .Get("state")
                               .Get("country")
                               .Execute();

                var address = string.Join(", ", new[]
                {
                    fragment.Content <string>("address"),
                    fragment.Content <string>("city"),
                    fragment.Content <string>("state"),
                    fragment.Content <string>("country")
                }.Where(x => !string.IsNullOrEmpty(x)));

                hotels.Add(new
                {
                    name        = fragment.Content <string>("name"),
                    description = fragment.Content <string>("description"),
                    address     = address
                });
            }

            return(Request.CreateResponse(new Result(hotels, queryJson)));
        }