protected void btnSearch_Click(object sender, EventArgs e)
        {
            txtPageName.Text = txtPageName.Text.Trim();

            if (txtPageName.Text.Length == 0)
            {
                lstAvailablePage.Items.Clear();
                btnAdd.Enabled = false;
                return;
            }

            List <SearchResult> similarPages = SearchClass.Search(new SearchField[] { SearchField.PageFullName }, txtPageName.Text, SearchOptions.AtLeastOneWord);

            lstAvailablePage.Items.Clear();

            foreach (SearchResult page in similarPages)
            {
                if (page.DocumentType == DocumentType.Page)
                {
                    PageDocument pageDocument = page.Document as PageDocument;
                    PageInfo     pageInfo     = Pages.FindPage(pageDocument.PageFullName);
                    lstAvailablePage.Items.Add(new ListItem(FormattingPipeline.PrepareTitle(pageDocument.Title, false, FormattingContext.Other, pageInfo), pageDocument.PageFullName));
                }
            }

            btnAdd.Enabled = lstAvailablePage.Items.Count > 0;
        }
Beispiel #2
0
        /// <summary>
        /// Prints the results of the automatic search.
        /// </summary>
        public void PrintSearchResults()
        {
            StringBuilder sb = new StringBuilder(1000);

            List <SearchResult> similarPages = SearchClass.Search(new SearchField[] { SearchField.PageFullName }, Request["Page"], SearchOptions.AtLeastOneWord);

            List <PageInfo> results = new List <PageInfo>();

            foreach (SearchResult page in similarPages)
            {
                if (page.DocumentType == DocumentType.Page)
                {
                    PageDocument pageDocument = page.Document as PageDocument;
                    PageInfo     pageInfo     = Pages.FindPage(pageDocument.PageFullName);
                    results.Add(pageInfo);
                }
            }
            if (results.Count > 0)
            {
                sb.Append("<p>");
                sb.Append(Properties.Messages.WereYouLookingFor);
                sb.Append("</p>");
                sb.Append("<ul>");
                PageContent c;
                for (int i = 0; i < results.Count; i++)
                {
                    c = Content.GetPageContent(results[i], true);
                    sb.Append(@"<li><a href=""");
                    UrlTools.BuildUrl(sb, Tools.UrlEncode(results[i].FullName), Settings.PageExtension);
                    sb.Append(@""">");
                    sb.Append(FormattingPipeline.PrepareTitle(c.Title, false, FormattingContext.PageContent, c.PageInfo));
                    sb.Append("</a></li>");
                }
                sb.Append("</ul>");
            }
            else
            {
                sb.Append("<p>");
                sb.Append(Properties.Messages.NoSimilarPages);
                sb.Append("</p>");
            }
            sb.Append(@"<br /><p>");
            sb.Append(Properties.Messages.YouCanAlso);
            sb.Append(@" <a href=""");
            UrlTools.BuildUrl(sb, "Search.aspx?Query=", Tools.UrlEncode(Request["Page"]));
            sb.Append(@""">");
            sb.Append(Properties.Messages.PerformASearch);
            sb.Append("</a> ");
            sb.Append(Properties.Messages.Or);
            sb.Append(@" <a href=""");
            UrlTools.BuildUrl(sb, "Edit.aspx?Page=", Tools.UrlEncode(Request["Page"]));
            sb.Append(@"""><b>");
            sb.Append(Properties.Messages.CreateThePage);
            sb.Append("</b></a> (");
            sb.Append(Properties.Messages.CouldRequireLogin);
            sb.Append(").</p>");

            lblSearchResults.Text = sb.ToString();
        }
        protected void btnSearch_Click(object sender, EventArgs e)
        {
            lstAvailablePage.Items.Clear();
            btnAddPage.Enabled = false;

            txtPageName.Text = txtPageName.Text.Trim();

            if (txtPageName.Text.Length == 0)
            {
                return;
            }

            List <SearchResult> similarPages = SearchClass.Search(new SearchField[] { SearchField.PageFullName }, txtPageName.Text, SearchOptions.AtLeastOneWord);

            List <PageInfo> pages = new List <PageInfo>();

            foreach (SearchResult page in similarPages)
            {
                if (page.DocumentType == DocumentType.Page)
                {
                    PageDocument pageDocument = page.Document as PageDocument;
                    PageInfo     pageInfo     = Pages.FindPage(pageDocument.PageFullName);
                    pages.Add(pageInfo);
                }
            }

            string cp = CurrentProvider;

            foreach (PageInfo page in
                     from p in pages
                     where p.Provider.GetType().FullName == cp
                     select p)
            {
                // Filter pages already in the list
                bool found = false;
                foreach (ListItem item in lstPages.Items)
                {
                    if (item.Value == page.FullName)
                    {
                        found = true;
                        break;
                    }
                }

                if (!found)
                {
                    PageContent content = Content.GetPageContent(page, false);
                    lstAvailablePage.Items.Add(new ListItem(FormattingPipeline.PrepareTitle(content.Title, false, FormattingContext.Other, page), page.FullName));
                }
            }

            btnAddPage.Enabled = lstAvailablePage.Items.Count > 0;
        }
Beispiel #4
0
        /// <summary>
        /// Performs a search.
        /// </summary>
        /// <param name="query">The search query.</param>
        /// <param name="mode">The search mode.</param>
        /// <param name="selectedCategories">The selected categories.</param>
        /// <param name="searchUncategorized">A value indicating whether to search uncategorized pages.</param>
        /// <param name="searchInAllNamespacesAndCategories">A value indicating whether to search in all namespaces and categories.</param>
        /// <param name="searchFilesAndAttachments">A value indicating whether to search files and attachments.</param>
        private void PerformSearch(string query, SearchOptions mode, List <string> selectedCategories, bool searchUncategorized, bool searchInAllNamespacesAndCategories, bool searchFilesAndAttachments)
        {
            List <SearchResult> results = null;
            DateTime            begin   = DateTime.Now;

            try {
                List <SearchField> searchFields = new List <SearchField>(2)
                {
                    SearchField.Title, SearchField.Content
                };
                if (searchFilesAndAttachments)
                {
                    searchFields.AddRange(new SearchField[] { SearchField.FileName, SearchField.FileContent });
                }
                results = SearchClass.Search(currentWiki, searchFields.ToArray(), query, mode);
            }
            catch (ArgumentException ex) {
                Log.LogEntry("Search threw an exception\n" + ex.ToString(), EntryType.Warning, SessionFacade.CurrentUsername, currentWiki);
                results = new List <SearchResult>();
            }
            DateTime end = DateTime.Now;

            // Build a list of SearchResultRow for display in the repeater
            List <SearchResultRow> rows = new List <SearchResultRow>(Math.Min(results.Count, MaxResults));

            string currentUser = SessionFacade.GetCurrentUsername();

            string[] currentGroups = SessionFacade.GetCurrentGroupNames(currentWiki);

            AuthChecker authChecker = new AuthChecker(Collectors.CollectorsBox.GetSettingsProvider(currentWiki));

            CategoryInfo[] pageCategories;
            int            count = 0;

            foreach (SearchResult res in results)
            {
                // Filter by category
                PageContent currentPage = null;
                pageCategories = new CategoryInfo[0];

                if (res.DocumentType == DocumentType.Page)
                {
                    PageDocument doc = res.Document as PageDocument;
                    currentPage    = Pages.FindPage(doc.Wiki, doc.PageFullName);
                    pageCategories = Pages.GetCategoriesForPage(currentPage);

                    // Verify permissions
                    bool canReadPage = authChecker.CheckActionForPage(currentPage.FullName,
                                                                      Actions.ForPages.ReadPage, currentUser, currentGroups);
                    if (!canReadPage)
                    {
                        continue;                                  // Skip
                    }
                }
                else if (res.DocumentType == DocumentType.Message)
                {
                    MessageDocument doc = res.Document as MessageDocument;
                    currentPage    = Pages.FindPage(doc.Wiki, doc.PageFullName);
                    pageCategories = Pages.GetCategoriesForPage(currentPage);

                    // Verify permissions
                    bool canReadDiscussion = authChecker.CheckActionForPage(currentPage.FullName,
                                                                            Actions.ForPages.ReadDiscussion, currentUser, currentGroups);
                    if (!canReadDiscussion)
                    {
                        continue;                                        // Skip
                    }
                }
                else if (res.DocumentType == DocumentType.Attachment)
                {
                    PageAttachmentDocument doc = res.Document as PageAttachmentDocument;
                    currentPage    = Pages.FindPage(doc.Wiki, doc.PageFullName);
                    pageCategories = Pages.GetCategoriesForPage(currentPage);

                    // Verify permissions
                    bool canDownloadAttn = authChecker.CheckActionForPage(currentPage.FullName,
                                                                          Actions.ForPages.DownloadAttachments, currentUser, currentGroups);
                    if (!canDownloadAttn)
                    {
                        continue;                                      // Skip
                    }
                }
                else if (res.DocumentType == DocumentType.File)
                {
                    FileDocument             doc      = res.Document as FileDocument;
                    string[]                 fields   = doc.FileName.Split('|');
                    IFilesStorageProviderV40 provider = Collectors.CollectorsBox.FilesProviderCollector.GetProvider(fields[0], currentWiki);
                    string directory = Tools.GetDirectoryName(fields[1]);

                    // Verify permissions
                    bool canDownloadFiles = authChecker.CheckActionForDirectory(provider, directory,
                                                                                Actions.ForDirectories.DownloadFiles, currentUser, currentGroups);
                    if (!canDownloadFiles)
                    {
                        continue;                                       // Skip
                    }
                }

                string currentNamespace = DetectNamespace();
                if (string.IsNullOrEmpty(currentNamespace))
                {
                    currentNamespace = null;
                }

                if (currentPage != null)
                {
                    // Check categories match, if page is set

                    if (searchInAllNamespacesAndCategories ||
                        Array.Find(pageCategories,
                                   delegate(CategoryInfo c) {
                        return(selectedCategories.Contains(c.FullName));
                    }) != null || pageCategories.Length == 0 && searchUncategorized)
                    {
                        // ... then namespace
                        if (searchInAllNamespacesAndCategories ||
                            NameTools.GetNamespace(currentPage.FullName) == currentNamespace)
                        {
                            rows.Add(SearchResultRow.CreateInstance(res));
                            count++;
                        }
                    }
                }
                else
                {
                    // No associated page (-> file), add result
                    rows.Add(SearchResultRow.CreateInstance(res));
                    count++;
                }

                if (count >= MaxResults)
                {
                    break;
                }
            }

            rptResults.DataSource = rows;
            rptResults.DataBind();
        }