public async Task<IEnumerable<SearchResultItem>> SearchAsync(string searchText, int projectId)
 {
     var query = new SearchQuery(searchText)
     {
         SearchFields = "id,title,details,tags,events",
         Select = "id",
         
     };
     if (projectId != default(int))
     {
         query.Filter = string.Format("projectid eq '{0}'", projectId);
     }
     var result = await QueryClient.SearchAsync(IndexName, query);
     if (result.IsSuccess)
     {
         return
             result.Body.Records.Select(
                 r =>
                     new SearchResultItem
                     {
                         Id = int.Parse((string) r.Properties["id"]),
                         SearchScore = (float) r.Score
                     });
     }
     return new SearchResultItem[0];
 }
        /// <summary>
        /// Search an index.
        /// </summary>
        /// <param name="indexName"></param>
        /// <param name="query"></param>
        /// <returns></returns>
        public Task<IApiResponse<SearchQueryResult>> SearchAsync(string indexName, SearchQuery query)
        {
            var request = new ApiRequest("indexes/{0}/docs", HttpMethod.Get);
            if (!String.IsNullOrEmpty(query.Query))
                request.AddQueryParameter("search", query.Query);
            if (query.Mode.HasValue)
                request.AddQueryParameter("searchMode", query.Mode.ToString().ToLower());
            if (!String.IsNullOrEmpty(query.SearchFields))
                request.AddQueryParameter("searchFields", query.SearchFields);
            if (query.Skip > 0)
                request.AddQueryParameter("$skip", query.Skip.ToString(CultureInfo.InvariantCulture));
            if (query.Top > 0)
                request.AddQueryParameter("$top", query.Top.ToString(CultureInfo.InvariantCulture));
            if (query.Count)
                request.AddQueryParameter("$count", query.Count.ToString().ToLower());
            if (!String.IsNullOrEmpty(query.OrderBy))
                request.AddQueryParameter("$orderby", query.OrderBy);
            if (!String.IsNullOrEmpty(query.Select))
                request.AddQueryParameter("$select", query.Select);
            if (!String.IsNullOrEmpty(query.Facet))
            {
                if (query.Facet.Contains(","))
                {
                    foreach (var facet in query.Facet.Split(new[] { ',' }, StringSplitOptions.RemoveEmptyEntries).Select(f => f.Trim()))
                        request.AddQueryParameter("facet", facet);
                }
                else
                {
                    request.AddQueryParameter("facet", query.Facet);
                }
            }
            if (!String.IsNullOrEmpty(query.Filter))
                request.AddQueryParameter("$filter", query.Filter);
            if (!String.IsNullOrEmpty(query.Highlight))
                request.AddQueryParameter("highlight", query.Highlight);
            if (!String.IsNullOrEmpty(query.ScoringProfile))
                request.AddQueryParameter("scoringProfile", query.ScoringProfile);
            if (!String.IsNullOrEmpty(query.ScoringParameter))
                request.AddQueryParameter("scoringParameter", query.ScoringParameter);

            return _connection.Execute<SearchQueryResult>(request
                .WithUriParameter(indexName));
        }
        /// <summary>
        /// Search an index.
        /// </summary>
        /// <param name="indexName"></param>
        /// <param name="query"></param>
        /// <param name="cancellationToken">cancellation token</param>
        /// <returns></returns>
        public Task<IApiResponse<SearchQueryResult>> SearchAsync(string indexName, SearchQuery query, CancellationToken cancellationToken = default(CancellationToken))
        {
            var request = new ApiRequest("indexes/{0}/docs", HttpMethod.Get);
            if (!String.IsNullOrEmpty(query.Query))
                request.AddQueryParameter("search", query.Query);
            if (query.Mode.HasValue)
                request.AddQueryParameter("searchMode", query.Mode.ToString().ToLower());
            if (!String.IsNullOrEmpty(query.SearchFields))
                request.AddQueryParameter("searchFields", query.SearchFields);
            if (query.Skip > 0)
                request.AddQueryParameter("$skip", query.Skip.ToString(CultureInfo.InvariantCulture));
            if (query.Top > 0)
                request.AddQueryParameter("$top", query.Top.ToString(CultureInfo.InvariantCulture));
            if (query.Count)
                request.AddQueryParameter("$count", query.Count.ToString().ToLower());
            if (!String.IsNullOrEmpty(query.OrderBy))
                request.AddQueryParameter("$orderby", query.OrderBy);
            if (!String.IsNullOrEmpty(query.Select))
                request.AddQueryParameter("$select", query.Select);
            if (query.Facets != null && query.Facets.Any())
                request.AddQueryParameter("facet", query.Facets);
            if (!String.IsNullOrEmpty(query.Filter))
                request.AddQueryParameter("$filter", query.Filter);
            if (!String.IsNullOrEmpty(query.Highlight))
                request.AddQueryParameter("highlight", query.Highlight);

            // Both HighlightPreTag AND HighlightPostTag need to be set together
            if (!String.IsNullOrEmpty(query.HighlightPreTag) && !String.IsNullOrEmpty(query.HighlightPostTag))
            {
                request.AddQueryParameter("highlightPreTag", query.HighlightPreTag);
                request.AddQueryParameter("highlightPostTag", query.HighlightPostTag);
            }
            if (!String.IsNullOrEmpty(query.ScoringProfile))
                request.AddQueryParameter("scoringProfile", query.ScoringProfile);
            if (query.ScoringParameters != null && query.ScoringParameters.Any())
                request.AddQueryParameter("scoringParameter", query.ScoringParameters);

            return _connection.Execute<SearchQueryResult>(request.WithUriParameter(indexName), cancellationToken);
        }
        public async Task<ActionResult> IndexPost([Bind(Prefix = "SearchRequest")]SearchRequest searchRequest)
        {
            string serviceName = ConfigurationManager.AppSettings["AzureSearch:ServiceName"];
            string primaryApiKey = ConfigurationManager.AppSettings["AzureSearch:ApiKey"];
            using (var apicConnection = ApiConnection.Create(serviceName, primaryApiKey))
            {
                var queryClient = new IndexQueryClient(apicConnection);
                var query = new SearchQuery(searchRequest.SearchTerm)
                    .Filter(string.Format("Year gt {0} and Year lt {1}", searchRequest.YearStart, searchRequest.YearEnd))
                    .Facet("Year")
                    .Top(100);

                IApiResponse<SearchQueryResult> searchResults = await queryClient.SearchAsync("movies", query);
                var movies = searchResults.Body.Records.Select(x => new MovieResult
                {
                    Id = x.Properties["Id"].ToString(),
                    Title = x.Properties["Name"].ToString(),
                    Year = int.Parse(x.Properties["Year"].ToString()),
                    Rating = double.Parse(x.Properties["Rating"].ToString()),
                    ImageUrl = x.Properties["Image"].ToString(),
                    Url = x.Properties["Url"].ToString(),
                    Episode = x.Properties["Episode"] != null
                        ? x.Properties["Episode"].ToString()
                        : null
                });

                KeyValuePair<string, FacetResult[]> yearFacet = searchResults.Body.Facets.FirstOrDefault();

                return View(new HomeViewModel
                {
                    Movies = movies,
                    SearchRequest = searchRequest,
                    Facets = (yearFacet.Value != null)
                        ? yearFacet.Value.ToDictionary(x => x.Value, x => x.Count)
                        : new Dictionary<string, long>()
                });
            }
        }
        public object BuildQuery(ISearchCriteria criteria)
        {
            var builder = new SearchQuery();
            var filterBuilder = new StringBuilder();
            var queryBuilder = new StringBuilder();

            builder.Skip(criteria.StartingRecord);
            builder.Top(criteria.RecordsToRetrieve);
            builder.Count(true);

            #region Sorting

            // Add sort order
            if (criteria.Sort != null)
            {
                var fields = criteria.Sort.GetSort();
                foreach (var field in fields)
                {
                    builder.OrderBy = String.Format("{0}{1}{2}", String.IsNullOrEmpty(builder.OrderBy) ? "" : builder.OrderBy + ",", field.FieldName, field.IsDescending ? " desc" : "");
                }
            }

            #endregion

            #region CatalogItemSearchCriteria
            if (criteria is CatalogItemSearchCriteria)
            {
                var c = criteria as CatalogItemSearchCriteria;

                if (!String.IsNullOrEmpty(c.SearchPhrase))
                {
                    queryBuilder.Query(c.SearchPhrase);
                }


                filterBuilder.Filter("startdate", c.StartDate, "lt");

                /*
                if (c.StartDateFrom.HasValue)
                {
                    mainQuery.Must(m => m
                        .Range(r => r.Field("startdate").From(c.StartDateFrom.Value.ToString("s")))
                   );
                }
                 * */

                if (c.EndDate.HasValue)
                {
                    //filterBuilder.Filter("enddate", c.EndDate.Value, "gt");
                }

                filterBuilder.Filter("sys__hidden", "false");

                if (c.Outlines != null && c.Outlines.Count > 0)
                {
                    queryBuilder.Query("sys__outline", c.Outlines.OfType<string>().ToArray());
                }


                if (!String.IsNullOrEmpty(c.Catalog))
                {
                    filterBuilder.FilterContains("catalog", c.Catalog);
                }

                

            }
            #endregion

            builder.Filter = filterBuilder.ToString();
            builder.Query = queryBuilder.ToString();

            return builder;
        }
 public static async Task<IApiResponse<SearchQueryResult>> Search(string search)
 {
     var conn = ApiConnection.Create(Keys.ListingsServiceUrl, Keys.ListingsServiceKey);
     var queryClient = new IndexQueryClient(conn);
     var query = new SearchQuery(search)
         .Count(true)
         .Select("Id,Color,Options,Type,Package,Image")
         .OrderBy("Color")
         .Highlight("Package");
     var searchResults = await queryClient.SearchAsync(Keys.ListingsServiceIndexName, query);
     return searchResults;
 }
 public async Task<IApiResponse<SearchQueryResult>> Search(string indexName, SearchQuery query)
 {
     var response = await QueryClient.SearchAsync(indexName, query).ConfigureAwait(false);
     return response;
 }