public ActionResult Search(string q, int?page)
        {
            if (string.IsNullOrWhiteSpace(q))
            {
                return(new EmptyResult());
            }

            var pageNumber = page.GetValueOrDefault(1);

            var searchProvider = SearchManager.Provider;

            var contextLanguage = this.HttpContext.GetContextLanguageInfo();

            var query = new CrmEntityQuery(q, pageNumber, PaginatedList.PageSize, new[] { "adx_issue" }, contextLanguage.ContextLanguage, contextLanguage.IsCrmMultiLanguageEnabled);

            ICrmEntityIndexSearcher searcher;

            try
            {
                searcher = searchProvider.GetIndexSearcher();
            }
            catch (IndexNotFoundException)
            {
                searchProvider.GetIndexBuilder().BuildIndex();

                searcher = searchProvider.GetIndexSearcher();
            }

            var results = searcher.Search(query);

            searcher.Dispose();

            return(View("SearchResults", results));
        }
Example #2
0
        public override void Render(Context context, TextWriter result)
        {
            IPortalLiquidContext portalLiquidContext;

            if (!context.TryGetPortalLiquidContext(out portalLiquidContext))
            {
                return;
            }

            var searchProvider = GetSearchProvider(context);

            // Allow empty query text, to allow return of top-ranking results based only on filter.
            string queryText = TryGetAttributeValue(context, "query", out queryText)
                                ? queryText
                                : string.Empty;

            string filter;

            TryGetAttributeValue(context, "filter", out filter);

            string pageValue;

            int page = TryGetAttributeValue(context, "page", out pageValue) &&
                       int.TryParse(pageValue, out page)
                                ? page
                                : 1;

            string pageSizeValue;

            int pageSize = (TryGetAttributeValue(context, "page_size", out pageSizeValue) || TryGetAttributeValue(context, "pagesize", out pageSizeValue)) &&
                           int.TryParse(pageSizeValue, out pageSize)
                                ? pageSize
                                : 10;

            string logicalNamesValue;

            var logicalNames = (TryGetAttributeValue(context, "logical_names", out logicalNamesValue) || TryGetAttributeValue(context, "logicalnames", out logicalNamesValue))
                                ? logicalNamesValue.Split(new[] { ',', ' ' }, StringSplitOptions.RemoveEmptyEntries)
                                : Enumerable.Empty <string>();

            // TODO check this here for context when this is called to make sure this still works
            var contextLanguage = HttpContext.Current.GetContextLanguageInfo();

            var query = new CrmEntityQuery(queryText, page, pageSize, logicalNames, contextLanguage.ContextLanguage, contextLanguage.IsCrmMultiLanguageEnabled, filter);

            context.Stack(() =>
            {
                context[string.IsNullOrEmpty(_variableName) ? "searchindex" : _variableName] = new SearchIndexQueryDrop(portalLiquidContext, searchProvider, query);

                RenderAll(NodeList, context, result);
            });
        }
        public ActionResult Search(Dictionary <string, string> parameters, string query, string logicalNames, string filter, int pageNumber, int pageSize = DefaultPageSize,
                                   FacetConstraints[] facetConstraints = null, string sortingOption = "Relevance", int initialConstraintsToLocalize = DefaultInitialConstraintsToLocalize)
        {
            if (pageSize < 0)
            {
                pageSize = DefaultPageSize;
            }

            if (pageSize > DefaultMaxPageSize)
            {
                pageSize = DefaultMaxPageSize;
            }

            var queryText  = GetQueryText(query, parameters);
            var filterText = GetFilterText(filter, parameters);
            ContextLanguageInfo contextLanguage;
            var multiLanguageEnabled = TryGetLanguageCode(out contextLanguage);

            if (string.IsNullOrWhiteSpace(queryText) && string.IsNullOrWhiteSpace(filterText))
            {
                return(new JObjectResult(new JObject
                {
                    { "itemCount", 0 },
                    { "pageNumber", pageNumber },
                    { "pageSize", pageSize },
                    { "pageCount", 0 },
                    { "items", new JArray() }
                }));
            }

            var provider = SearchManager.Provider;

            if (facetConstraints != null)
            {
                facetConstraints =
                    facetConstraints.Select(
                        x =>
                        new FacetConstraints
                {
                    FacetName   = x.FacetName,
                    Constraints = x.Constraints.SelectMany(c => c.Split(','))
                }).ToArray();
            }

            string searchTerm = parameters.ContainsKey("Query") ? parameters["Query"] : string.Empty;             // This is needed for Notes/Attachement Search
            // If they specify facet constraints, we'll do a faceted search
            // TODO this doesn't work, facetConstraints is never null
            var entityQuery = new CrmEntityQuery(queryText, pageNumber, pageSize, getLogicalNamesAsEnumerable(logicalNames), contextLanguage.ContextLanguage, multiLanguageEnabled, filterText, facetConstraints, sortingOption, searchTerm);

            var searcher = this.GetSearcher(provider);

            using (searcher)
            {
                var results   = searcher.Search(entityQuery);
                var itemCount = results.ApproximateTotalHits;
                var pageCount = itemCount > 0 ? (int)Math.Ceiling(itemCount / (double)results.PageSize) : 0;

                ADXTrace.Instance.TraceInfo(TraceCategory.Application, string.Format("Search term:{0}, length: {1}, results contain {2} items", searchTerm, searchTerm.Length, itemCount));

                var jsonResult = new JObject {
                    { "itemCount", itemCount },
                    { "pageNumber", results.PageNumber },
                    { "pageSize", results.PageSize },
                    { "pageCount", pageCount },
                    { "items", new JArray(results.Select(GetSearchResultJson)) }
                };

                if (results.FacetViews != null)
                {
                    jsonResult.Add("facetViews", GetFacetViewsJson(results.FacetViews, logicalNames, initialConstraintsToLocalize));

                    if (results.SortingOptions != null)
                    {
                        //todo: add calculation for sort options: searchOrder
                        jsonResult.Add("sortingOptions", GetSortingOptionsJson(results.SortingOptions));
                    }
                }
                return(new JObjectResult(jsonResult));
            }
        }
        protected override IEnumerable ExecuteSelect(DataSourceSelectArguments args)
        {
            args.AddSupportedCapabilities(DataSourceCapabilities.Page);
            args.AddSupportedCapabilities(DataSourceCapabilities.RetrieveTotalRowCount);

            args.RaiseUnsupportedCapabilitiesError(this);

            var parameters = Owner.SelectParameters.GetValues(HttpContext.Current, Owner);

            var filter       = GetFilter(args, parameters);
            var logicalNames = GetLogicalNames(args, parameters);
            var pageSize     = GetPageSize(args, parameters);
            var pageNumber   = GetPageNumber(args, parameters, pageSize);
            var queryText    = GetQueryText(args, parameters);
            ContextLanguageInfo contextLanguage;
            var multiLanguageEnabled = TryGetLanguageCode(out contextLanguage);

            if (string.IsNullOrWhiteSpace(queryText) && string.IsNullOrWhiteSpace(filter))
            {
                args.TotalRowCount = 0;

                return(new CrmEntitySearchResultPage(new List <ICrmEntitySearchResult>(), 0, pageNumber, pageSize));
            }

            var provider = SearchManager.GetProvider(Owner.SearchProvider);
            var query    = new CrmEntityQuery(queryText, pageNumber, pageSize, logicalNames, contextLanguage.ContextLanguage, multiLanguageEnabled, filter);

            var selectingArgs = new SearchDataSourceSelectingEventArgs(provider, query);

            Owner.OnSelecting(selectingArgs);

            if (selectingArgs.Cancel)
            {
                args.TotalRowCount = 0;

                return(new CrmEntitySearchResultPage(new List <ICrmEntitySearchResult>(), 0, pageNumber, pageSize));
            }

            try
            {
                using (var searcher = provider.GetIndexSearcher())
                {
                    var results = searcher.Search(query);

                    args.TotalRowCount = results.ApproximateTotalHits;

                    Owner.OnSelected(new SearchDataSourceStatusEventArgs(provider, query, results));

                    return(results);
                }
            }
            catch (Exception e)
            {
                ADXTrace.Instance.TraceError(TraceCategory.Application, e.ToString());

                var selectedArgs = new SearchDataSourceStatusEventArgs(provider, query, new CrmEntitySearchResultPage(new List <ICrmEntitySearchResult>(), 0, pageNumber, pageSize))
                {
                    Exception = e
                };

                Owner.OnSelected(selectedArgs);

                if (!selectedArgs.ExceptionHandled)
                {
                    throw;
                }

                args.TotalRowCount = 0;

                return(new CrmEntitySearchResultPage(new List <ICrmEntitySearchResult>(), 0, pageNumber, pageSize));
            }
        }