Пример #1
0
        /// <summary>
        /// Using CMS search API fills dataset with raw data.
        /// </summary>
        /// <param name="query">Text to search</param>
        /// <param name="pageIndex">Page index</param>
        /// <param name="pageSize">Page size</param>
        /// <param name="numberOfResults">Total number of search results</param>
        private void SearchInternal(string query, int pageIndex, int pageSize, out int numberOfResults)
        {
            var documentCondition = new DocumentSearchCondition(null, mCultureName, mDefaultCulture, combineWithDefaultCulture: false);
            var condition         = new SearchCondition(documentCondition: documentCondition);
            var searchExpression  = SearchSyntaxHelper.CombineSearchCondition(query, condition);

            var parameters = new SearchParameters
            {
                SearchFor                 = searchExpression,
                Path                      = "/%",
                ClassNames                = null,
                CurrentCulture            = mCultureName,
                DefaultCulture            = mDefaultCulture,
                CombineWithDefaultCulture = false,
                CheckPermissions          = false,
                SearchInAttachments       = false,
                User                      = MembershipContext.AuthenticatedUser,
                SearchIndexes             = mSearchIndexName,
                StartingPosition          = pageIndex * pageSize,
                NumberOfResults           = 0,
                NumberOfProcessedResults  = 100,
                DisplayResults            = pageSize
            };

            // Search and save results
            mRawResults     = SearchHelper.Search(parameters);
            numberOfResults = parameters.NumberOfResults;
        }
Пример #2
0
        /// <summary>
        /// Performs search and populates the returned raw data into the internal search service dataset. Logs activity.
        /// </summary>
        private void PerformSearch(SearchOptions options)
        {
            var documentCondition = new DocumentSearchCondition(null, options.CultureName, options.DefaultCultureCode, options.CombineWithDefaultCulture);
            var condition         = new SearchCondition(documentCondition: documentCondition);
            var searchExpression  = SearchSyntaxHelper.CombineSearchCondition(options.Query, condition);

            var parameters = new SearchParameters
            {
                SearchFor                 = searchExpression,
                Path                      = "/%",
                ClassNames                = null,
                CurrentCulture            = options.CultureName,
                DefaultCulture            = options.DefaultCultureCode,
                CombineWithDefaultCulture = options.CombineWithDefaultCulture,
                CheckPermissions          = false,
                SearchInAttachments       = false,
                User                      = MembershipContext.AuthenticatedUser,
                SearchIndexes             = options.SearchIndexNames.Join(";"),
                StartingPosition          = (options.PageNumber - 1) * options.PageSize,
                NumberOfResults           = 0,
                NumberOfProcessedResults  = 100,
                DisplayResults            = options.PageSize
            };

            // Search and save results
            rawResults           = SearchInternal(parameters);
            totalNumberOfResults = parameters.NumberOfResults;
        }
Пример #3
0
    /// <summary>
    /// Performs search.
    /// </summary>
    private SearchResult PredictiveSearch(string searchText)
    {
        // Prepare search text
        var docCondition = new DocumentSearchCondition(PredictiveSearchDocumentTypes, PredictiveSearchCultureCode, CultureHelper.GetDefaultCultureCode(SiteContext.CurrentSiteName), PredictiveSearchCombineWithDefaultCulture);
        var condition    = new SearchCondition(PredictiveSearchCondition, PredictiveSearchMode, PredictiveSearchOptions, docCondition);

        string searchCondition = SearchSyntaxHelper.CombineSearchCondition(searchText, condition);

        // Prepare parameters
        SearchParameters parameters = new SearchParameters()
        {
            SearchFor                 = searchCondition,
            SearchSort                = PredictiveSearchSort,
            Path                      = PredictiveSearchPath,
            ClassNames                = PredictiveSearchDocumentTypes,
            CurrentCulture            = PredictiveSearchCultureCode,
            DefaultCulture            = CultureHelper.GetDefaultCultureCode(SiteContext.CurrentSiteName),
            CombineWithDefaultCulture = PredictiveSearchCombineWithDefaultCulture,
            CheckPermissions          = PredictiveSearchCheckPermissions,
            SearchInAttachments       = false,
            User                      = MembershipContext.AuthenticatedUser,
            SearchIndexes             = PredictiveSearchIndexes,
            StartingPosition          = 0,
            DisplayResults            = PredictiveSearchMaxResults,
            NumberOfProcessedResults  = 100 > PredictiveSearchMaxResults ? PredictiveSearchMaxResults : 100,
            NumberOfResults           = 0,
            AttachmentWhere           = null,
            AttachmentOrderBy         = null,
            BlockFieldOnlySearch      = PredictiveSearchBlockFieldOnlySearch,
        };

        var results = SearchHelper.Search(parameters);

        return(results);
    }
Пример #4
0
        /// <summary>
        /// 获取某个单据的所有操作记录
        /// </summary>
        /// <param name="documentID"></param>
        /// <param name="documentType"></param>
        /// <returns></returns>
        public QueryResultList <DocumentOperation> GetHisOperations(string documentID, string documentType)
        {
            DocumentSearchCondition con = new DocumentSearchCondition()
            {
                DocumentID   = documentID,
                DocumentType = documentType,
            };

            return(base.GetItems(con));
        }
Пример #5
0
        public IEnumerable <DataRow> Search(string phrase, string indexName, string path, int results, bool checkPermissions)
        {
            var index = SearchIndexInfoProvider.GetSearchIndexInfo(indexName);

            if (index == null)
            {
                yield break;
            }

            var searchText = string.Format("+({0})", phrase);
            var culture    = LocalizationContext.CurrentCulture.CultureCode;

            var documentSearchCondition = new DocumentSearchCondition {
                Culture = culture
            };
            var condition = new SearchCondition(documentCondition: documentSearchCondition);

            searchText = SearchSyntaxHelper.CombineSearchCondition(searchText, condition);

            SearchParameters parameters = new SearchParameters()
            {
                SearchFor                 = searchText,
                SearchSort                = "##SCORE##",
                Path                      = path,
                CurrentCulture            = culture,
                DefaultCulture            = null,
                CombineWithDefaultCulture = false,
                CheckPermissions          = checkPermissions,
                SearchInAttachments       = false,
                User                      = (UserInfo)MembershipContext.AuthenticatedUser,
                SearchIndexes             = index.IndexName,
                StartingPosition          = 0,
                DisplayResults            = results,
                NumberOfProcessedResults  = 5000,
                NumberOfResults           = results,
                AttachmentWhere           = String.Empty,
                AttachmentOrderBy         = String.Empty,
            };

            var dataset = CacheHelper.Cache <DataSet>(() => SearchHelper.Search(parameters), new CacheSettings(1, $"search|{indexName}|{path}|{phrase}|{results}|{checkPermissions}|{culture}"));

            if (dataset != null)
            {
                foreach (DataTable table in dataset.Tables)
                {
                    foreach (DataRow dr in table.Rows)
                    {
                        yield return(dr);
                    }
                }
            }
        }
Пример #6
0
        protected override List <DocumentOperation> GetingItems(System.Data.Linq.DataContext dc, SearchCondition search)
        {
            IQueryable <DocumentOperation> ret = dc.GetTable <DocumentOperation>();

            if (search is DocumentSearchCondition)
            {
                DocumentSearchCondition con = search as DocumentSearchCondition;
                if (!string.IsNullOrEmpty(con.DocumentID))
                {
                    ret = ret.Where(item => item.DocumentID == con.DocumentID);
                }
                if (!string.IsNullOrEmpty(con.DocumentType))
                {
                    ret = ret.Where(item => item.DocumentType == con.DocumentType);
                }
            }
            return(ret.ToList());
        }
Пример #7
0
        public void Search_CheckParameters_Query(string searchQuery, string culture, string defaultCulture, bool combineWithDefaultCulture)
        {
            var parameters = Search(
                query: searchQuery,
                culture: culture,
                defaultCulture: defaultCulture,
                combineWithDefaultCulture: combineWithDefaultCulture
                )
                             .Parameters;

            var documentCondition = new DocumentSearchCondition(null, culture, defaultCulture, combineWithDefaultCulture);
            var condition         = new SearchCondition(documentCondition: documentCondition);
            var searchExpression  = SearchSyntaxHelper.CombineSearchCondition(searchQuery, condition);

            CMSAssert.All(
                () => Assert.AreEqual(parameters.SearchFor, searchExpression),
                () => Assert.AreEqual(parameters.CurrentCulture, culture),
                () => Assert.AreEqual(parameters.DefaultCulture, defaultCulture),
                () => Assert.AreEqual(parameters.CombineWithDefaultCulture, combineWithDefaultCulture)
                );
        }
Пример #8
0
        /// <summary>
        /// Performs search and populates the returned raw data into the internal search service dataset.
        /// </summary>
        /// <param name="query">Text to search</param>
        /// <param name="pageIndex">Zero-based page index</param>
        /// <param name="pageSize">Page size</param>
        /// <param name="numberOfResults">Total number of search results</param>
        private void SearchInternal(string query, int pageIndex, int pageSize, out int numberOfResults)
        {
            var documentCondition = new DocumentSearchCondition(null, mCultureName, mDefaultCulture, mCombineWithDefaultCulture);
            var condition = new SearchCondition(documentCondition: documentCondition);
            var searchExpression = SearchSyntaxHelper.CombineSearchCondition(query, condition);

            var parameters = new SearchParameters
            {
                SearchFor = searchExpression,
                Path = "/%",
                ClassNames = null,
                CurrentCulture = mCultureName,
                DefaultCulture = mDefaultCulture,
                CombineWithDefaultCulture = mCombineWithDefaultCulture,
                CheckPermissions = false,
                SearchInAttachments = false,
                User = MembershipContext.AuthenticatedUser,
                SearchIndexes = mSearchIndexNames.Join(";"),
                StartingPosition = pageIndex * pageSize,
                NumberOfResults = 0,
                NumberOfProcessedResults = 100,
                DisplayResults = pageSize
            };

            // Search and save results
            mRawResults = SearchHelper.Search(parameters);
            numberOfResults = parameters.NumberOfResults;
        }
Пример #9
0
    /// <summary>
    /// Perform search.
    /// </summary>
    protected void Search()
    {
        if (StopProcessing)
        {
            // Do nothing
        }
        else
        {
            // Check if the search was triggered
            bool searchAllowed = SearchOnEachPageLoad || QueryHelper.Contains("searchtext");

            // Get query strings
            string searchText = QueryHelper.GetString("searchtext", "");
            // Check whether string passes text requirements settings
            bool searchTextIsNotEmptyOrNotRequired = (!SearchTextRequired || !String.IsNullOrEmpty(searchText));

            // Proceed when search was triggered and search text is passing requirements settings.
            // Requirements setting could be overriden on this level by obsolete web.config key. The reason is backward compatibility.
            // Search text required web part setting was introduced after this web.config key. Key default value was at the time set to true.
            // This default value had the same effect as this new web part setting. When somenone changed the web.config key to false and then upgraded the solution,
            // required wep part setting with default value true would override previous behaviour. That's the reason why this obsolete key can override this setting.
            if (searchAllowed && (searchTextIsNotEmptyOrNotRequired || !SearchHelper.SearchOnlyWhenContentPresent))
            {
                string         searchMode     = QueryHelper.GetString("searchMode", "");
                SearchModeEnum searchModeEnum = searchMode.ToEnum <SearchModeEnum>();

                // Get current culture
                string culture = CultureCode;
                if (string.IsNullOrEmpty(culture))
                {
                    culture = ValidationHelper.GetString(ViewState["CultureCode"], LocalizationContext.PreferredCultureCode);
                }

                // Get default culture
                string defaultCulture = CultureHelper.GetDefaultCultureCode(SiteContext.CurrentSiteName);

                // Resolve path
                string path = Path;
                if (!string.IsNullOrEmpty(path))
                {
                    path = MacroResolver.ResolveCurrentPath(Path);
                }

                if (PortalContext.ViewMode.IsLiveSite())
                {
                    if (AnalyticsHelper.JavascriptLoggingEnabled(SiteContext.CurrentSiteName))
                    {
                        ScriptHelper.RegisterWebServiceCallFunction(Page);
                        string script = "WebServiceCall('" + URLHelper.GetAbsoluteUrl("~/CMSPages/WebAnalyticsService.asmx") +
                                        "','LogSearch', '{\"keyword\":" +
                                        // Serialize raw search text to encode '<' and similar characters, then escape '\'
                                        new JavaScriptSerializer().Serialize(searchText).Replace(@"\", @"\\") +
                                        ", \"pageGUID\":\"" + DocumentContext.CurrentPageInfo.DocumentGUID + "\"}')";
                        ScriptHelper.RegisterStartupScript(Page, typeof(string), "logSearch", script, true);
                    }
                    else
                    {
                        // Log on site keywords
                        AnalyticsHelper.LogOnSiteSearchKeywords(SiteContext.CurrentSiteName, DocumentContext.CurrentAliasPath, culture, searchText, 0, 1);
                    }
                }

                // Prepare search text
                var docCondition = new DocumentSearchCondition(DocumentTypes, culture, defaultCulture, CombineWithDefaultCulture);

                var searchCond = SearchCondition;
                if (!string.IsNullOrEmpty(FilterSearchCondition) && (searchModeEnum == SearchModeEnum.AnyWordOrSynonyms))
                {
                    // Make sure the synonyms are expanded before the filter condition is applied (filter condition is Lucene syntax, cannot be expanded)
                    searchCond     = SearchSyntaxHelper.ExpandWithSynonyms(searchCond, docCondition.Culture);
                    searchModeEnum = SearchModeEnum.AnyWord;
                }

                var condition = new SearchCondition(searchCond + FilterSearchCondition, searchModeEnum, SearchOptions, docCondition, DoFuzzySearch);

                searchText = SearchSyntaxHelper.CombineSearchCondition(searchText, condition);

                // Get positions and ranges for search method
                int startPosition     = 0;
                int numberOfProceeded = 100;
                int displayResults    = 100;
                if (pgr.PageSize != 0 && pgr.GroupSize != 0)
                {
                    // Reset pager if needed
                    if (mResetPager)
                    {
                        pgr.CurrentPage = 1;
                    }

                    startPosition = (pgr.CurrentPage - 1) * pgr.PageSize;
                    // Only results covered by current page group are proccessed (filtered) for performance reasons. This may cause decrease of the number of results while paging.
                    numberOfProceeded = (((pgr.CurrentPage / pgr.GroupSize) + 1) * pgr.PageSize * pgr.GroupSize) + pgr.PageSize;
                    displayResults    = pgr.PageSize;
                }

                if ((MaxResults > 0) && (numberOfProceeded > MaxResults))
                {
                    numberOfProceeded = MaxResults;
                }

                // Combine regular search sort with filter sort
                string srt       = ValidationHelper.GetString(SearchSort, String.Empty).Trim();
                string filterSrt = ValidationHelper.GetString(FilterSearchSort, String.Empty).Trim();

                if (!String.IsNullOrEmpty(filterSrt))
                {
                    if (!String.IsNullOrEmpty(srt))
                    {
                        srt += ", ";
                    }

                    srt += filterSrt;
                }

                // Prepare parameters
                SearchParameters parameters = new SearchParameters
                {
                    SearchFor                 = searchText,
                    SearchSort                = srt,
                    Path                      = path,
                    ClassNames                = DocumentTypes,
                    CurrentCulture            = culture,
                    DefaultCulture            = defaultCulture,
                    CombineWithDefaultCulture = CombineWithDefaultCulture,
                    CheckPermissions          = CheckPermissions,
                    SearchInAttachments       = SearchInAttachments,
                    User                      = MembershipContext.AuthenticatedUser,
                    SearchIndexes             = Indexes,
                    StartingPosition          = startPosition,
                    DisplayResults            = displayResults,
                    NumberOfProcessedResults  = numberOfProceeded,
                    NumberOfResults           = 0,
                    AttachmentWhere           = AttachmentsWhere,
                    AttachmentOrderBy         = AttachmentsOrderBy,
                    BlockFieldOnlySearch      = BlockFieldOnlySearch,
                };

                // Search
                DataSet results = SearchHelper.Search(parameters);

                int numberOfResults = parameters.NumberOfResults;

                if ((MaxResults > 0) && (numberOfResults > MaxResults))
                {
                    numberOfResults = MaxResults;
                }

                // Fill repeater with results
                repSearchResults.DataSource = results;
                repSearchResults.PagerForceNumberOfResults = numberOfResults;
                PagerForceNumberOfResults = numberOfResults;
                repSearchResults.DataBind();

                // Call page binding event
                if (OnPageBinding != null)
                {
                    OnPageBinding(this, null);
                }

                // Show now results found ?
                if (numberOfResults == 0)
                {
                    if (ShowParsingErrors)
                    {
                        Exception searchError = SearchContext.LastError;
                        if (searchError != null)
                        {
                            ShowError(GetString("smartsearch.searcherror") + " " + searchError.Message);
                        }
                    }
                    lblNoResults.Text    = NoResultsText;
                    lblNoResults.Visible = true;
                }
            }
            else
            {
                if (!String.IsNullOrEmpty(SearchTextValidationFailedText) && searchAllowed)
                {
                    pnlSearchResults.AddCssClass(SearchTextValidationFailedCssClass);
                    lblNoResults.Text    = SearchTextValidationFailedText;
                    lblNoResults.Visible = true;
                }
                else
                {
                    Visible = false;
                }
            }

            // Invoke search completed event
            if (OnSearchCompleted != null)
            {
                OnSearchCompleted(Visible);
            }
        }
    }
Пример #10
0
    /// <summary>
    /// Perform search.
    /// </summary>
    protected void Search()
    {
        if (StopProcessing)
        {
            // Do nothing
        }
        else
        {
            // Check if the search was triggered
            bool searchAllowed = SearchOnEachPageLoad || QueryHelper.Contains("searchtext");

            // Get query strings
            string searchText = QueryHelper.GetString("searchtext", "");
            // Check whether string passes text requirements settings
            bool searchTextIsNotEmptyOrNotRequired = (!SearchTextRequired || !String.IsNullOrEmpty(searchText));

            // Proceed when search was triggered and search text is passing requirements settings.
            // Requirements setting could be overridden on this level by obsolete web.config key. The reason is backward compatibility.
            // Search text required web part setting was introduced after this web.config key. Key default value was at the time set to true.
            // This default value had the same effect as this new web part setting. When someone changed the web.config key to false and then upgraded the solution,
            // required web part setting with default value true would override previous behavior. That's the reason why this obsolete key can override this setting.
            if (searchAllowed && (searchTextIsNotEmptyOrNotRequired || !SearchHelper.SearchOnlyWhenContentPresent))
            {
                string         searchMode     = QueryHelper.GetString("searchMode", "");
                SearchModeEnum searchModeEnum = EnumStringRepresentationExtensions.ToEnum <SearchModeEnum>(searchMode);

                // Get current culture
                string culture = CultureCode;
                if (string.IsNullOrEmpty(culture))
                {
                    culture = ValidationHelper.GetString(ViewState["CultureCode"], LocalizationContext.PreferredCultureCode);
                }

                var siteName = SiteContext.CurrentSiteName;

                // Get default culture
                string defaultCulture = CultureHelper.GetDefaultCultureCode(siteName);

                // Resolve path
                string path = Path;
                if (!string.IsNullOrEmpty(path))
                {
                    path = MacroResolver.ResolveCurrentPath(Path);
                }

                // Prepare search text
                var docCondition = new DocumentSearchCondition(DocumentTypes, culture, defaultCulture, CombineWithDefaultCulture);

                var searchCond = SearchCondition;
                if (!string.IsNullOrEmpty(FilterSearchCondition) && (searchModeEnum == SearchModeEnum.AnyWordOrSynonyms))
                {
                    // Make sure the synonyms are expanded before the filter condition is applied (filter condition is Lucene syntax, cannot be expanded)
                    searchCond = SearchSyntaxHelper.ExpandWithSynonyms(searchCond, docCondition.Culture);
                }

                var condition = new SearchCondition(searchCond + FilterSearchCondition, searchModeEnum, SearchOptions, docCondition, DoFuzzySearch);

                searchText = SearchSyntaxHelper.CombineSearchCondition(searchText, condition);

                // Get positions and ranges for search method
                int startPosition     = 0;
                int numberOfProceeded = 100;
                int displayResults    = 100;
                if (pgr.PageSize != 0 && pgr.GroupSize != 0)
                {
                    // Reset pager if needed
                    if (mResetPager)
                    {
                        pgr.CurrentPage = 1;
                    }

                    startPosition = (pgr.CurrentPage - 1) * pgr.PageSize;
                    // Only results covered by current page group are proccessed (filtered) for performance reasons. This may cause decrease of the number of results while paging.
                    numberOfProceeded = (((pgr.CurrentPage / pgr.GroupSize) + 1) * pgr.PageSize * pgr.GroupSize) + pgr.PageSize;
                    displayResults    = pgr.PageSize;
                }

                if ((MaxResults > 0) && (numberOfProceeded > MaxResults))
                {
                    numberOfProceeded = MaxResults;
                }

                // Combine regular search sort with filter sort
                string srt       = ValidationHelper.GetString(SearchSort, String.Empty).Trim();
                string filterSrt = ValidationHelper.GetString(FilterSearchSort, String.Empty).Trim();

                if (!String.IsNullOrEmpty(filterSrt))
                {
                    if (!String.IsNullOrEmpty(srt))
                    {
                        srt += ", ";
                    }

                    srt += filterSrt;
                }

                // Prepare parameters
                SearchParameters parameters = new SearchParameters
                {
                    SearchFor                 = searchText,
                    SearchSort                = srt,
                    Path                      = path,
                    ClassNames                = DocumentTypes,
                    CurrentCulture            = culture,
                    DefaultCulture            = defaultCulture,
                    CombineWithDefaultCulture = CombineWithDefaultCulture,
                    CheckPermissions          = CheckPermissions,
                    SearchInAttachments       = SearchInAttachments,
                    User                      = MembershipContext.AuthenticatedUser,
                    SearchIndexes             = Indexes,
                    StartingPosition          = startPosition,
                    DisplayResults            = displayResults,
                    NumberOfProcessedResults  = numberOfProceeded,
                    NumberOfResults           = 0,
                    AttachmentWhere           = AttachmentsWhere,
                    AttachmentOrderBy         = AttachmentsOrderBy,
                    BlockFieldOnlySearch      = BlockFieldOnlySearch,
                };

                // Search
                var results = SearchHelper.Search(parameters);

                int numberOfResults = parameters.NumberOfResults;
                if ((MaxResults > 0) && (numberOfResults > MaxResults))
                {
                    numberOfResults = MaxResults;
                }

                // Limit displayed results according to MaxPages property
                var maxDisplayedResultsOnMaxPages = MaxPages * PageSize;
                // Apply only if MaxPages and PageSize properties are set
                if ((maxDisplayedResultsOnMaxPages > 0) && (numberOfResults > maxDisplayedResultsOnMaxPages))
                {
                    numberOfResults = maxDisplayedResultsOnMaxPages;
                }

                // Fill repeater with results
                repSearchResults.DataSource = results.Items;
                repSearchResults.PagerForceNumberOfResults = numberOfResults;
                PagerForceNumberOfResults = numberOfResults;
                repSearchResults.DataBind();

                // Call page binding event
                if (OnPageBinding != null)
                {
                    OnPageBinding(this, null);
                }

                // Show no results found ?
                if (numberOfResults == 0)
                {
                    if (ShowParsingErrors)
                    {
                        Exception searchError = results.LastError;
                        if (searchError != null)
                        {
                            ShowError(GetString("smartsearch.searcherror") + " " + HTMLHelper.HTMLEncode(searchError.Message));
                        }
                    }
                    lblNoResults.Text    = NoResultsText;
                    lblNoResults.Visible = true;
                }
            }
            else
            {
                if (!String.IsNullOrEmpty(SearchTextValidationFailedText) && searchAllowed)
                {
                    pnlSearchResults.AddCssClass(SearchTextValidationFailedCssClass);
                    lblNoResults.Text    = SearchTextValidationFailedText;
                    lblNoResults.Visible = true;
                }
                else
                {
                    Visible = false;
                }
            }

            // Invoke search completed event
            if (OnSearchCompleted != null)
            {
                OnSearchCompleted(Visible);
            }
        }
    }
    /// <summary>
    /// Performs search.
    /// </summary>
    private DataSet PredictiveSearch(string searchText)
    {
        // Prepare search text
        var docCondition = new DocumentSearchCondition(PredictiveSearchDocumentTypes, PredictiveSearchCultureCode, CultureHelper.GetDefaultCultureCode(SiteContext.CurrentSiteName), PredictiveSearchCombineWithDefaultCulture);
        var condition = new SearchCondition(PredictiveSearchCondition, PredictiveSearchMode, PredictiveSearchOptions, docCondition);

        string searchCondition = SearchSyntaxHelper.CombineSearchCondition(searchText, condition);

        // Prepare parameters
        SearchParameters parameters = new SearchParameters()
        {
            SearchFor = searchCondition,
            SearchSort = PredictiveSearchSort,
            Path = PredictiveSearchPath,
            ClassNames = PredictiveSearchDocumentTypes,
            CurrentCulture = PredictiveSearchCultureCode,
            DefaultCulture = CultureHelper.GetDefaultCultureCode(SiteContext.CurrentSiteName),
            CombineWithDefaultCulture = PredictiveSearchCombineWithDefaultCulture,
            CheckPermissions = PredictiveSearchCheckPermissions,
            SearchInAttachments = false,
            User = MembershipContext.AuthenticatedUser,
            SearchIndexes = PredictiveSearchIndexes,
            StartingPosition = 0,
            DisplayResults = PredictiveSearchMaxResults,
            NumberOfProcessedResults = 100 > PredictiveSearchMaxResults ? PredictiveSearchMaxResults : 100,
            NumberOfResults = 0,
            AttachmentWhere = null,
            AttachmentOrderBy = null,
            BlockFieldOnlySearch = PredictiveSearchBlockFieldOnlySearch,
        };

        // Search
        DataSet results = SearchHelper.Search(parameters);
        return results;
    }
    /// <summary>
    /// Perform search.
    /// </summary>
    protected void Search()
    {
        if (StopProcessing)
        {
            // Do nothing
        }
        else
        {
            // Check if the search was triggered
            bool searchAllowed = SearchOnEachPageLoad || QueryHelper.Contains("searchtext");

            // Get query strings 
            string searchText = QueryHelper.GetString("searchtext", "");
            // Check whether string passes text requirements settings
            bool searchTextIsNotEmptyOrNotRequired = (!SearchTextRequired || !String.IsNullOrEmpty(searchText));

            // Proceed when search was triggered and search text is passing requirements settings. 
            // Requirements setting could be overriden on this level by obsolete web.config key. The reason is backward compatibility.
            // Search text required web part setting was introduced after this web.config key. Key default value was at the time set to true.
            // This default value had the same effect as this new web part setting. When somenone changed the web.config key to false and then upgraded the solution,
            // required wep part setting with default value true would override previous behaviour. That's the reason why this obsolete key can override this setting.  
            if (searchAllowed && (searchTextIsNotEmptyOrNotRequired || !SearchHelper.SearchOnlyWhenContentPresent))
            {
                string searchMode = QueryHelper.GetString("searchMode", "");
                SearchModeEnum searchModeEnum = searchMode.ToEnum<SearchModeEnum>();

                // Get current culture
                string culture = CultureCode;
                if (string.IsNullOrEmpty(culture))
                {
                    culture = ValidationHelper.GetString(ViewState["CultureCode"], LocalizationContext.PreferredCultureCode);
                }

                // Get default culture
                string defaultCulture = CultureHelper.GetDefaultCultureCode(SiteContext.CurrentSiteName);

                // Resolve path
                string path = Path;
                if (!string.IsNullOrEmpty(path))
                {
                    path = MacroResolver.ResolveCurrentPath(Path);
                }

                if (PortalContext.ViewMode.IsLiveSite())
                {
                    if (AnalyticsHelper.JavascriptLoggingEnabled(SiteContext.CurrentSiteName))
                    {
                        ScriptHelper.RegisterWebServiceCallFunction(Page);
                        string script = "WebServiceCall('" + URLHelper.GetAbsoluteUrl("~/CMSPages/WebAnalyticsService.asmx") + 
                                         "','LogSearch', '{\"keyword\":" + 
                                         // Serialize raw search text to encode '<' and similar characters, then escape '\'
                                         new JavaScriptSerializer().Serialize(searchText).Replace(@"\", @"\\") + 
                                         ", \"pageGUID\":\"" + DocumentContext.CurrentPageInfo.DocumentGUID + "\"}')";
                        ScriptHelper.RegisterStartupScript(Page, typeof(string), "logSearch", script, true);
                    }
                    else
                    {
                        // Log on site keywords
                        AnalyticsHelper.LogOnSiteSearchKeywords(SiteContext.CurrentSiteName, DocumentContext.CurrentAliasPath, culture, searchText, 0, 1);
                    }
                }

                // Prepare search text
                var docCondition = new DocumentSearchCondition(DocumentTypes, culture, defaultCulture, CombineWithDefaultCulture);

                var searchCond = SearchCondition;
                if (!string.IsNullOrEmpty(FilterSearchCondition) && (searchModeEnum == SearchModeEnum.AnyWordOrSynonyms))
                {
                    // Make sure the synonyms are expanded before the filter condition is applied (filter condition is Lucene syntax, cannot be expanded)
                    searchCond = SearchSyntaxHelper.ExpandWithSynonyms(searchCond, docCondition.Culture);
                    searchModeEnum = SearchModeEnum.AnyWord;
                }

                var condition = new SearchCondition(searchCond + FilterSearchCondition, searchModeEnum, SearchOptions, docCondition, DoFuzzySearch);

                searchText = SearchSyntaxHelper.CombineSearchCondition(searchText, condition);

                // Get positions and ranges for search method
                int startPosition = 0;
                int numberOfProceeded = 100;
                int displayResults = 100;
                if (pgr.PageSize != 0 && pgr.GroupSize != 0)
                {
                    // Reset pager if needed
                    if (mResetPager)
                    {
                        pgr.CurrentPage = 1;
                    }

                    startPosition = (pgr.CurrentPage - 1) * pgr.PageSize;
                    // Only results covered by current page group are proccessed (filtered) for performance reasons. This may cause decrease of the number of results while paging. 
                    numberOfProceeded = (((pgr.CurrentPage / pgr.GroupSize) + 1) * pgr.PageSize * pgr.GroupSize) + pgr.PageSize;
                    displayResults = pgr.PageSize;
                }

                if ((MaxResults > 0) && (numberOfProceeded > MaxResults))
                {
                    numberOfProceeded = MaxResults;
                }

                // Combine regular search sort with filter sort
                string srt = ValidationHelper.GetString(SearchSort, String.Empty).Trim();
                string filterSrt = ValidationHelper.GetString(FilterSearchSort, String.Empty).Trim();

                if (!String.IsNullOrEmpty(filterSrt))
                {
                    if (!String.IsNullOrEmpty(srt))
                    {
                        srt += ", ";
                    }

                    srt += filterSrt;
                }

                // Prepare parameters
                SearchParameters parameters = new SearchParameters
                {
                    SearchFor = searchText,
                    SearchSort = srt,
                    Path = path,
                    ClassNames = DocumentTypes,
                    CurrentCulture = culture,
                    DefaultCulture = defaultCulture,
                    CombineWithDefaultCulture = CombineWithDefaultCulture,
                    CheckPermissions = CheckPermissions,
                    SearchInAttachments = SearchInAttachments,
                    User = MembershipContext.AuthenticatedUser,
                    SearchIndexes = Indexes,
                    StartingPosition = startPosition,
                    DisplayResults = displayResults,
                    NumberOfProcessedResults = numberOfProceeded,
                    NumberOfResults = 0,
                    AttachmentWhere = AttachmentsWhere,
                    AttachmentOrderBy = AttachmentsOrderBy,
                    BlockFieldOnlySearch = BlockFieldOnlySearch,
                };

                // Search
                DataSet results = SearchHelper.Search(parameters);

                int numberOfResults = parameters.NumberOfResults;

                if ((MaxResults > 0) && (numberOfResults > MaxResults))
                {
                    numberOfResults = MaxResults;
                }

                // Fill repeater with results
                repSearchResults.DataSource = results;
                repSearchResults.PagerForceNumberOfResults = numberOfResults;
                PagerForceNumberOfResults = numberOfResults;
                repSearchResults.DataBind();

                // Call page binding event
                if (OnPageBinding != null)
                {
                    OnPageBinding(this, null);
                }

                // Show now results found ?
                if (numberOfResults == 0)
                {
                    if (ShowParsingErrors)
                    {
                        Exception searchError = SearchContext.LastError;
                        if (searchError != null)
                        {
                            ShowError(GetString("smartsearch.searcherror") + " " + searchError.Message);
                        }
                    }
                    lblNoResults.Text = NoResultsText;
                    lblNoResults.Visible = true;
                }
            }
            else
            {
                if (!String.IsNullOrEmpty(SearchTextValidationFailedText) && searchAllowed)
                {
                    pnlSearchResults.AddCssClass(SearchTextValidationFailedCssClass);
                    lblNoResults.Text = SearchTextValidationFailedText;
                    lblNoResults.Visible = true;
                }
                else
                {
                    Visible = false;
                }
            }

            // Invoke search completed event
            if (OnSearchCompleted != null)
            {
                OnSearchCompleted(Visible);
            }
        }
    }