private static void ConvertEachBibTexPairIntoWord2007Pair(XmlDocument doc, XmlNode node_source, string fields) { List <string> field_list = SplitFields(fields); foreach (string field in field_list) { string[] field_split = field.Split(new char[] { '=' }, 2, StringSplitOptions.RemoveEmptyEntries); if (2 != field_split.Length) { Logging.Warn("Unable to process BibTex field '{0}'", field); } else { string key = field_split[0].Trim(); string val = field_split[1].Trim(); val = val.TrimStart('{').TrimEnd('}'); val = BibTexCharacterMap.BibTexToASCII(val); string field_type_word2007 = TranslateFieldType(key); XmlNode node_record = doc.CreateElement(NS_TAG, field_type_word2007, NS); // Process authors specifically if (key.Equals("author")) { XmlNode node_name_list = doc.CreateElement(NS_TAG, "NameList", NS); XmlNode node_author = doc.CreateElement(NS_TAG, "Author", NS); node_author.AppendChild(node_name_list); node_record.AppendChild(node_author); string[] authors = NameTools.SplitAuthors_LEGACY(val); foreach (string author in authors) { string first_name; string last_name; NameTools.SplitName_LEGACY(author, out first_name, out last_name); XmlNode node_last = doc.CreateElement(NS_TAG, "Last", NS); node_last.AppendChild(doc.CreateTextNode(last_name)); XmlNode node_first = doc.CreateElement(NS_TAG, "First", NS); node_first.AppendChild(doc.CreateTextNode(first_name)); XmlNode node_person = doc.CreateElement(NS_TAG, "Person", NS); node_person.AppendChild(node_last); node_person.AppendChild(node_first); node_name_list.AppendChild(node_person); } } else { node_record.AppendChild(doc.CreateTextNode(val)); } node_source.AppendChild(node_record); } } }
private static void ExpandAuthors(PDFDocument doc, NodeControl node_control) { WPFDoEvents.AssertThisCodeIs_NOT_RunningInTheUIThread(); ASSERT.Test(doc != null); FeatureTrackingManager.Instance.UseFeature(Features.Brainstorm_ExploreLibrary_Document_Authors); if (doc != null) { string authors = doc.AuthorsCombined; if (String.IsNullOrEmpty(authors) || Constants.UNKNOWN_AUTHORS == authors) { return; } WPFDoEvents.InvokeInUIThread(() => { WPFDoEvents.AssertThisCodeIsRunningInTheUIThread(); List <NameTools.Name> names = new List <NameTools.Name>(); string[] authors_split = NameTools.SplitAuthors_LEGACY(authors); foreach (string author_split in authors_split) { string first_names, last_name; NameTools.SplitName_LEGACY(author_split, out first_names, out last_name); string initial = String.IsNullOrEmpty(first_names) ? null : first_names.Substring(0, 1); PDFAuthorNodeContent pdf_author = new PDFAuthorNodeContent(doc.LibraryRef.Id, last_name, initial); NodeControlAddingByKeyboard.AddChildToNodeControl(node_control, pdf_author, false); } }); } }
public static bool DoesBibTeXMatchDocument(BibTexItem bibtex_item, PDFDocument pdf_document, out PDFSearchResultSet search_result_set) { try { string authors_string = BibTexTools.GetAuthor(bibtex_item); if (!String.IsNullOrEmpty(authors_string)) { List <NameTools.Name> names = NameTools.SplitAuthors(authors_string, PDFDocument.UNKNOWN_AUTHORS); StringBuilder sb = new StringBuilder(); foreach (NameTools.Name name in names) { sb.AppendFormat("\"{0}\" ", name.last_name); } string names_search_string = sb.ToString(); if (!String.IsNullOrEmpty(names_search_string)) { search_result_set = PDFSearcher.Search(pdf_document, 1, names_search_string, PDFSearcher.MATCH_CONTAINS); if (0 < search_result_set.Count) { return(true); } } } } catch (Exception) { } search_result_set = new PDFSearchResultSet(); return(false); }
/// <summary> /// Gets the pages in the selected namespace. /// </summary> /// <returns>The pages.</returns> private IList <PageInfo> GetPages() { NamespaceInfo nspace = Pages.FindNamespace(lstNamespace.SelectedValue); List <PageInfo> pages = Pages.GetPages(nspace); var orphanPages = Pages.GetOrphanedPages(pages); var result = new List <PageInfo>(pages.Count); var filter = txtFilter.Text.Trim().ToLower(System.Globalization.CultureInfo.CurrentCulture); foreach (PageInfo page in pages) { if (NameTools.GetLocalName(page.FullName).ToLower(System.Globalization.CultureInfo.CurrentCulture).Contains(filter)) { if (chkOrphansOnly.Checked && !orphanPages.Contains(page.FullName)) { continue; } else { result.Add(page); } } } result.Sort(new PageNameComparer()); return(result); }
public static string MakeExportFilename(PDFDocument pdf_document) { string year = pdf_document.YearCombined; if (year == Constants.UNKNOWN_YEAR) { year = ""; } string authors = ""; List<NameTools.Name> author_names = NameTools.SplitAuthors(pdf_document.AuthorsCombined); if (0 < author_names.Count) { authors = author_names[0].last_name; } string title = pdf_document.TitleCombined; string filename = String.Format("{0}{1} - {2}", authors, year, title); filename = filename.Trim(); filename = FileTools.MakeSafeFilename(filename); filename = filename + ".pdf"; return filename; }
static void Init() { // Get existing open window or if none, make a new one: NameTools window = (NameTools)EditorWindow.GetWindow(typeof(NameTools)); window.Show(); }
/// <summary> /// Loads the available pages and selects the current one. /// </summary> private void LoadDefaultPages() { // Populate default page, if there is a namespace selected if (!string.IsNullOrEmpty(txtCurrentNamespace.Value)) { NamespaceInfo nspace = Pages.FindNamespace( txtCurrentNamespace.Value != RootName ? txtCurrentNamespace.Value : null); List <PageInfo> pages = Pages.GetPages(nspace); string currentDefaultPage = nspace != null ? nspace.DefaultPage.FullName : Settings.DefaultPage; lstDefaultPage.Items.Clear(); foreach (PageInfo page in pages) { ListItem item = new ListItem(NameTools.GetLocalName(page.FullName), page.FullName); if (page.FullName == currentDefaultPage) { item.Selected = true; } lstDefaultPage.Items.Add(item); } } }
/// <summary> /// Populates the namespaces list for migration. /// </summary> /// <param name="page">The selected page.</param> /// <returns><c>true</c> if there is at least one valid target namespace, <c>false</c> otherwise.</returns> private bool PopulateTargetNamespaces(PageInfo page) { string currentUser = SessionFacade.GetCurrentUsername(); string[] currentGroups = SessionFacade.GetCurrentGroupNames(); lstTargetNamespace.Items.Clear(); NamespaceInfo pageNamespace = Pages.FindNamespace(NameTools.GetNamespace(page.FullName)); if (pageNamespace != null) { // Try adding Root as target namespace bool canManagePages = AuthChecker.CheckActionForNamespace(null, Actions.ForNamespaces.ManagePages, currentUser, currentGroups); if (canManagePages) { lstTargetNamespace.Items.Add(new ListItem("<root>", "")); } } // Try adding all other namespaces foreach (NamespaceInfo nspace in Pages.GetNamespaces().FindAll(n => n.Provider == page.Provider)) { if (pageNamespace == null || (pageNamespace != null && nspace.Name != pageNamespace.Name)) { bool canManagePages = AuthChecker.CheckActionForNamespace(nspace, Actions.ForNamespaces.ManagePages, currentUser, currentGroups); if (canManagePages) { lstTargetNamespace.Items.Add(new ListItem(nspace.Name, nspace.Name)); } } } return(lstTargetNamespace.Items.Count > 0); }
/// <summary> /// Adds a new Navigation Path. /// </summary> /// <param name="nspace">The target namespace (<c>null</c> for the root).</param> /// <param name="name">The Name.</param> /// <param name="pages">The Pages.</param> /// <param name="provider">The Provider to use for the new Navigation Path, or <c>null</c> for the default provider.</param> /// <returns>True if the Path is added successfully.</returns> public static bool AddNavigationPath(NamespaceInfo nspace, string name, List <PageInfo> pages, IPagesStorageProviderV30 provider) { var namespaceName = nspace != null ? nspace.Name : null; var fullName = NameTools.GetFullName(namespaceName, name); if (Exists(fullName)) { return(false); } if (provider == null) { provider = Collectors.PagesProviderCollector.GetProvider(Settings.DefaultPagesProvider); } NavigationPath newPath = provider.AddNavigationPath(namespaceName, name, pages.ToArray()); if (newPath != null) { Log.LogEntry("Navigation Path " + fullName + " added", EntryType.General, Log.SystemUsername); } else { Log.LogEntry("Creation failed for Navigation Path " + fullName, EntryType.Error, Log.SystemUsername); } return(newPath != null); }
/// <summary> /// Gets the categories for the current page, already formatted for display. /// </summary> /// <returns>The categories, formatted for display.</returns> private string GetFormattedPageCategories() { CategoryInfo[] categories = Pages.GetCategoriesForPage(currentPage); if (categories.Length == 0) { return(string.Format(@"<i><a href=""{0}"" title=""{1}"">{2}</a></i>", GetCategoryLink("-"), Properties.Messages.Uncategorized, Properties.Messages.Uncategorized)); } else { StringBuilder sb = new StringBuilder(categories.Length * 10); for (int i = 0; i < categories.Length; i++) { sb.AppendFormat(@"<a href=""{0}"" title=""{1}"">{2}</a>", GetCategoryLink(categories[i].FullName), NameTools.GetLocalName(categories[i].FullName), NameTools.GetLocalName(categories[i].FullName)); if (i != categories.Length - 1) { sb.Append(", "); } } return(sb.ToString()); } }
/// <summary> /// Appends a breadbrumb trail element. /// </summary> /// <param name="sb">The destination <see cref="T:StringBuilder" />.</param> /// <param name="page">The page to append.</param> /// <param name="dpPrefix">The drop-down menu ID prefix.</param> private void AppendBreadcrumb(StringBuilder sb, PageInfo page, string dpPrefix) { PageNameComparer comp = new PageNameComparer(); PageContent pc = Content.GetPageContent(page, true); string id = AppendBreadcrumbDropDown(sb, page, dpPrefix); string nspace = NameTools.GetNamespace(page.FullName); sb.Append("» "); if (comp.Compare(page, currentPage) == 0) { sb.Append("<b>"); } sb.AppendFormat(@"<a href=""{0}"" title=""{1}""{2}{3}{4}>{1}</a>", Tools.UrlEncode(page.FullName) + Settings.PageExtension, FormattingPipeline.PrepareTitle(pc.Title, false, FormattingContext.PageContent, currentPage) + (string.IsNullOrEmpty(nspace) ? "" : (" (" + NameTools.GetNamespace(page.FullName) + ")")), (id != null ? @" onmouseover=""javascript:return __ShowDropDown(event, '" + id + @"', this);""" : ""), (id != null ? @" id=""lnk" + id + @"""" : ""), (id != null ? @" onmouseout=""javascript:return __HideDropDown('" + id + @"');""" : "")); if (comp.Compare(page, currentPage) == 0) { sb.Append("</b>"); } sb.Append(" "); }
/// <summary> /// Activates the page editor. /// </summary> private void ActivatePageEditor() { lblCurrentPage.Text = txtCurrentPage.Value; txtNewName.Text = NameTools.GetLocalName(txtCurrentPage.Value); // Enable/disable page sections PageContent page = Pages.FindPage(currentWiki, txtCurrentPage.Value); NamespaceInfo nspace = Pages.FindNamespace(currentWiki, NameTools.GetNamespace(page.FullName)); string currentUser = SessionFacade.GetCurrentUsername(); string[] currentGroups = SessionFacade.GetCurrentGroupNames(currentWiki); AuthChecker authChecker = new AuthChecker(Collectors.CollectorsBox.GetSettingsProvider(currentWiki)); bool canApproveReject = AdminMaster.CanApproveDraft(page.Provider.CurrentWiki, page.FullName, currentUser, currentGroups); bool canDeletePages = authChecker.CheckActionForNamespace(nspace, Actions.ForNamespaces.DeletePages, currentUser, currentGroups); bool canManageAllPages = authChecker.CheckActionForNamespace(nspace, Actions.ForNamespaces.ManagePages, currentUser, currentGroups); bool canManagePage = authChecker.CheckActionForPage(page.FullName, Actions.ForPages.ManagePage, currentUser, currentGroups); bool canManageDiscussion = authChecker.CheckActionForPage(page.FullName, Actions.ForPages.ManageDiscussion, currentUser, currentGroups); bool namespaceAvailable = PopulateTargetNamespaces(page); // Approve/reject // Rename // Migrate // Rollback // Delete Backups // Clear discussion // Delete pnlApproveRevision.Enabled = canApproveReject; pnlRename.Enabled = canDeletePages; pnlMigrate.Enabled = canManageAllPages && namespaceAvailable; pnlRollback.Enabled = canManagePage; pnlDeleteBackups.Enabled = canManagePage; pnlClearDiscussion.Enabled = canManageDiscussion; pnlDelete.Enabled = canDeletePages; // Disable rename, migrate, delete for default page NamespaceInfo currentNamespace = Pages.FindNamespace(currentWiki, lstNamespace.SelectedValue); string currentDefaultPage = currentNamespace != null ? currentNamespace.DefaultPageFullName : Settings.GetDefaultPage(currentWiki); if (txtCurrentPage.Value == currentDefaultPage) { btnRename.Enabled = false; btnMigrate.Enabled = false; btnDeletePage.Enabled = false; } LoadDraft(txtCurrentPage.Value); LoadBackups(txtCurrentPage.Value); btnRollback.Enabled = lstRevision.Items.Count > 0; btnDeleteBackups.Enabled = lstBackup.Items.Count > 0; pnlList.Visible = false; pnlEditPage.Visible = true; ClearResultLabels(); }
/// <summary> /// Gets the pages in the selected namespace. /// </summary> /// <returns>The pages.</returns> private IList <PageContent> GetPages(NamespaceInfo nspace) { List <PageContent> pages = Pages.GetPages(currentWiki, nspace); var orphanPages = new List <string>(Pages.GetOrphanedPages(currentWiki, nspace)); List <PageContent> result = new List <PageContent>(pages.Count); string filter = txtFilter.Text.Trim().ToLower(System.Globalization.CultureInfo.CurrentCulture); foreach (PageContent page in pages) { if (NameTools.GetLocalName(page.FullName).ToLower(System.Globalization.CultureInfo.CurrentCulture).Contains(filter)) { if (chkOrphansOnly.Checked && !orphanPages.Contains(page.FullName)) { continue; } else { result.Add(page); } } } result.Sort(new PageNameComparer()); return(result); }
protected void btnDeletePage_Click(object sender, EventArgs e) { PageInfo page = Pages.FindPage(txtCurrentPage.Value); if (!AuthChecker.CheckActionForNamespace(Pages.FindNamespace(NameTools.GetNamespace(page.FullName)), Actions.ForNamespaces.DeletePages, SessionFacade.GetCurrentUsername(), SessionFacade.GetCurrentGroupNames())) { return; } Log.LogEntry("Page deletion requested for " + txtCurrentPage.Value, EntryType.General, Log.SystemUsername); bool done = Pages.DeletePage(page); if (done) { ResetPageList(); RefreshList(); lblDeleteResult.CssClass = "resultok"; lblDeleteResult.Text = Properties.Messages.PageDeleted; ReturnToList(); } else { lblDeleteResult.CssClass = "resulterror"; lblDeleteResult.Text = Properties.Messages.CouldNotDeletePage; } }
private static void Export_Directories_Authors(WebLibraryDetail web_library_detail, string base_path, Dictionary <string, PDFDocumentExportItem> pdf_document_export_items) { WshShell shell = new WshShell(); string authors_base_path = Path.GetFullPath(Path.Combine(base_path, @"authors")); Directory.CreateDirectory(authors_base_path); foreach (var item in pdf_document_export_items.Values) { try { List <NameTools.Name> names = NameTools.SplitAuthors(item.pdf_document.AuthorsCombined); foreach (var name in names) { string author_base_path = Path.GetFullPath(Path.Combine(authors_base_path, name.LastName_Initials)); Directory.CreateDirectory(author_base_path); string filename = Path.GetFullPath(Path.Combine(author_base_path, FileTools.MakeSafeFilename(item.pdf_document.TitleCombined) + ".lnk")); CreateShortcut(shell, item.filename, filename); } } catch (Exception ex) { Logging.Error(ex, "Error creating shortcut for " + item.filename); } } }
private static void Export_Directories_Authors(Library library, string base_path, Dictionary <string, PDFDocumentExportItem> pdf_document_export_items) { WshShell shell = new WshShell(); string authors_base_path = base_path + @"authors\"; Directory.CreateDirectory(authors_base_path); foreach (var item in pdf_document_export_items.Values) { try { List <NameTools.Name> names = NameTools.SplitAuthors(item.pdf_document.AuthorsCombined, PDFDocument.UNKNOWN_AUTHORS); foreach (var name in names) { string author_base_path = authors_base_path + name.LastName_Initials + @"\"; Directory.CreateDirectory(author_base_path); string filename = author_base_path + FileTools.MakeSafeFilename(item.pdf_document.TitleCombined) + ".lnk"; CreateShortcut(shell, item.filename, filename); } } catch (Exception ex) { Logging.Error(ex, "Error creating shortcut for " + item.filename); } } }
/// <summary> /// Prints the content. /// </summary> public void PrintContent() { StringBuilder sb = new StringBuilder(5000); string title = FormattingPipeline.PrepareTitle(content.Title, false, FormattingContext.PageContent, page); if (Request["Discuss"] == null) { string[] categories = (from c in Pages.GetCategoriesForPage(page) select NameTools.GetLocalName(c.FullName)).ToArray(); UserInfo user = Users.FindUser(content.User); sb.Append(@"<h1 class=""pagetitle"">"); sb.Append(title); sb.Append("</h1>"); sb.AppendFormat("<small>{0} {1} {2} {3} — {4}: {5}</small><br /><br />", Properties.Messages.ModifiedOn, Preferences.AlignWithTimezone(content.LastModified).ToString(Settings.DateTimeFormat), Properties.Messages.By, user != null ? Users.GetDisplayName(user) : content.User, Properties.Messages.CategorizedAs, categories.Length == 0 ? Properties.Messages.Uncategorized : string.Join(", ", categories)); sb.Append(Content.GetFormattedPageContent(page, true)); } else { sb.Append(@"<h1 class=""pagetitle"">"); sb.Append(title); sb.Append(" - Discussion</h1>"); PrintDiscussion(sb); } lblContent.Text = sb.ToString(); }
private void ExpandAuthors() { FeatureTrackingManager.Instance.UseFeature(Features.Brainstorm_ExploreLibrary_Document_Authors); PDFDocument pdf_document = pdf_document_node_content.PDFDocument; string authors = pdf_document.AuthorsCombined; if (String.IsNullOrEmpty(authors) || 0 == PDFDocument.UNKNOWN_AUTHORS.CompareTo(authors)) { return; } List <NameTools.Name> names = new List <NameTools.Name>(); string[] authors_split = NameTools.SplitAuthors_LEGACY(authors); foreach (string author_split in authors_split) { string first_names, last_name; NameTools.SplitName_LEGACY(author_split, out first_names, out last_name); string initial = String.IsNullOrEmpty(first_names) ? null : first_names.Substring(0, 1); PDFAuthorNodeContent pdf_author = new PDFAuthorNodeContent(pdf_document.Library.WebLibraryDetail.Id, last_name, initial); NodeControlAddingByKeyboard.AddChildToNodeControl(node_control, pdf_author, false); } }
protected void Page_Load(object sender, EventArgs e) { for (int i = 0; i < 1000; i++) { PageContent page = Pages.SetPageContent("root", "", "pagetest" + i, "Title of Pahe Test " + i, "testuser", DateTime.UtcNow, "", "Content of the test page " + i, new string[0], "", SaveMode.Normal); for (int j = 0; j < 200; j++) { Pages.SetPageContent("root", "", NameTools.GetLocalName(page.FullName), page.Title, page.User, DateTime.UtcNow, "", "Content of test page" + i + " at revision " + j, page.Keywords, page.Description, SaveMode.Backup); } } }
/// <summary> /// Sets the navigation paths label. /// </summary> private void SetupNavigationPaths() { string[] paths = NavigationPaths.PathsPerPage(currentPage); string currentPath = Request["NavPath"]; if (!string.IsNullOrEmpty(currentPath)) { currentPath = currentPath.ToLowerInvariant(); } if (!discussMode && !viewCodeMode && paths.Length > 0) { StringBuilder sb = new StringBuilder(500); sb.Append(Properties.Messages.Paths); sb.Append(": "); for (int i = 0; i < paths.Length; i++) { NavigationPath path = NavigationPaths.Find(paths[i]); if (path != null) { if (currentPath != null && paths[i].ToLowerInvariant().Equals(currentPath)) { sb.Append("<b>"); } sb.Append(@"<a href="""); sb.Append(UrlTools.BuildUrl("Default.aspx?Page=", Tools.UrlEncode(currentPage.FullName), "&NavPath=", Tools.UrlEncode(paths[i]))); sb.Append(@""" title="""); sb.Append(NameTools.GetLocalName(path.FullName)); sb.Append(@""">"); sb.Append(NameTools.GetLocalName(path.FullName)); sb.Append("</a>"); if (currentPath != null && paths[i].ToLowerInvariant().Equals(currentPath)) { sb.Append("</b>"); } if (i != paths.Length - 1) { sb.Append(", "); } } } lblNavigationPaths.Text = sb.ToString(); } else { lblNavigationPaths.Visible = false; } }
public static List <NameTools.Name> GetAuthorsForPDFDocument(PDFDocument pdf_document) { string authors = pdf_document.AuthorsCombined; if (String.IsNullOrEmpty(authors) || Constants.UNKNOWN_AUTHORS == authors) { return(EMPTY_NAMES); } List <NameTools.Name> names = NameTools.SplitAuthors(authors); return(names); }
/// <summary> /// Processes the renaming of a namespace. /// </summary> /// <param name="oldName">The old name of the namespace.</param> /// <param name="oldPages">The list of local names of the pages in the renamed namespace.</param> /// <param name="newName">The new name of the namespace.</param> /// <returns><c>true</c> if the operation completed successfully, <c>false</c> otherwise.</returns> public static bool ProcessNamespaceRenaming(string oldName, List <string> oldPages, string newName) { if (oldName == null) { throw new ArgumentNullException("oldName"); } if (oldName.Length == 0) { throw new ArgumentException("Old Name cannot be empty", "oldName"); } if (oldPages == null) { throw new ArgumentNullException("oldPages"); } foreach (string p in oldPages) { if (p == null) { throw new ArgumentNullException("oldPages"); } if (p.Length == 0) { throw new ArgumentException("Page cannot be empty", "oldPages"); } } if (newName == null) { throw new ArgumentNullException("newName"); } if (newName.Length == 0) { throw new ArgumentException("New Name cannot be empty", "newName"); } foreach (string p in oldPages) { SettingsProvider.AclManager.RenameResource( Actions.ForPages.ResourceMasterPrefix + NameTools.GetFullName(oldName, p), Actions.ForPages.ResourceMasterPrefix + NameTools.GetFullName(newName, p)); } return(SettingsProvider.AclManager.RenameResource( Actions.ForNamespaces.ResourceMasterPrefix + oldName, Actions.ForNamespaces.ResourceMasterPrefix + newName)); }
/// <summary> /// Determines whether a page is the default page of its namespace. /// </summary> /// <param name="page">The page.</param> /// <returns><c>true</c> if the page is the default namespace of its namespace, <c>false</c> otherwise.</returns> private bool IsDefaultPage(PageInfo page) { string localName, nspace; NameTools.ExpandFullName(page.FullName, out nspace, out localName); if (string.IsNullOrEmpty(nspace)) { return(localName.ToLowerInvariant() == Settings.DefaultPage.ToLowerInvariant()); } NamespaceInfo ns = Pages.FindNamespace(nspace); return(ns.DefaultPage != null && ns.DefaultPage.FullName.ToLowerInvariant() == page.FullName.ToLowerInvariant()); }
/// <summary> /// Searches for pages with name or title similar to a specified value. /// </summary> /// <param name="wiki">The wiki.</param> /// <param name="name">The name to look for (<c>null</c> for the root).</param> /// <param name="nspace">The namespace to search into.</param> /// <returns>The similar pages, if any.</returns> public static PageContent[] SearchSimilarPages(string wiki, string name, string nspace) { if (string.IsNullOrEmpty(nspace)) { nspace = null; } var searchFields = new [] { SearchField.PageFullName }; List <SearchResult> searchResults = Search(wiki, searchFields, name, SearchOptions.AtLeastOneWord); var result = new List <PageContent>(20); foreach (SearchResult res in searchResults) { var pageDoc = res.Document as PageDocument; if (pageDoc != null) { string pageNamespace = NameTools.GetNamespace(pageDoc.PageFullName); if (string.IsNullOrEmpty(pageNamespace)) { pageNamespace = null; } if (pageNamespace == nspace) { var page = new PageContent(pageDoc.PageFullName, null, new DateTime(), pageDoc.Title, null, new DateTime(), null, pageDoc.Content, null, null); result.Add(page); } } } // Search page names for matches List <PageContent> allPages = Pages.GetPages(wiki, Pages.FindNamespace(wiki, nspace)); var comp = new PageNameComparer(); string currentName = name.ToLowerInvariant(); foreach (PageContent page in allPages) { if (NameTools.GetLocalName(page.FullName).ToLowerInvariant().Contains(currentName)) { if (result.Find(p => comp.Compare(p, page) == 0) == null) { result.Add(page); } } } return(result.ToArray()); }
private static void Export_HTML_Authors(StringBuilder html, Library library, string base_path, Dictionary <string, PDFDocumentExportItem> pdf_document_export_items) { MultiMap <string, PDFDocumentExportItem> items_sliced = new MultiMap <string, PDFDocumentExportItem>(false); foreach (var item in pdf_document_export_items.Values) { List <NameTools.Name> names = NameTools.SplitAuthors(item.pdf_document.AuthorsCombined); foreach (var name in names) { items_sliced.Add(name.LastName_Initials, item); } } Export_HTML_XXX(html, "Authors", items_sliced); }
protected void btnNewCategory_Click(object sender, EventArgs e) { if (!CanManageCategoriesInCurrentNamespace()) { return; } lblNewCategoryResult.CssClass = ""; lblNewCategoryResult.Text = ""; txtNewCategory.Text = txtNewCategory.Text.Trim(); Page.Validate("newcat"); if (!Page.IsValid) { return; } txtNewCategory.Text = txtNewCategory.Text.Trim(); if (txtNewCategory.Text.Length == 0) { return; } if (Pages.FindCategory(NameTools.GetFullName(lstNamespace.SelectedValue, txtNewCategory.Text)) != null) { lblNewCategoryResult.CssClass = "resulterror"; lblNewCategoryResult.Text = Properties.Messages.CategoryAlreadyExists; return; } else { Log.LogEntry("Category creation requested for " + txtNewCategory.Text, EntryType.General, Log.SystemUsername); if (Pages.CreateCategory(lstNamespace.SelectedValue, txtNewCategory.Text)) { txtNewCategory.Text = ""; lblNewCategoryResult.CssClass = "resultok"; lblNewCategoryResult.Text = Properties.Messages.CategoryCreated; RefreshList(); } else { lblNewCategoryResult.CssClass = "resulterror"; lblNewCategoryResult.Text = Properties.Messages.CouldNotCreateCategory; } } }
/// <summary> /// Determines whether a page is the default page of its namespace. /// </summary> /// <param name="pageFullName">The page full name.</param> /// <returns><c>true</c> if the page is the default namespace of its namespace, <c>false</c> otherwise.</returns> private bool IsDefaultPage(string pageFullName) { string localName, nspace; NameTools.ExpandFullName(pageFullName, out nspace, out localName); if (string.IsNullOrEmpty(nspace)) { return(localName.ToLowerInvariant() == Settings.GetDefaultPage(currentWiki).ToLowerInvariant()); } else { NamespaceInfo ns = Pages.FindNamespace(currentWiki, nspace); return(ns.DefaultPageFullName != null && ns.DefaultPageFullName.ToLowerInvariant() == pageFullName.ToLowerInvariant()); } }
/// <summary> /// Searches for pages with name or title similar to a specified value. /// </summary> /// <param name="name">The name to look for (<c>null</c> for the root).</param> /// <param name="nspace">The namespace to search into.</param> /// <returns>The similar pages, if any.</returns> public static PageInfo[] SearchSimilarPages(string name, string nspace) { if (string.IsNullOrEmpty(nspace)) { nspace = null; } SearchResultCollection searchResults = Search(name, false, false, SearchOptions.AtLeastOneWord); var result = new List <PageInfo>(20); foreach (SearchResult res in searchResults) { var pageDoc = res.Document as PageDocument; if (pageDoc != null) { var pageNamespace = NameTools.GetNamespace(pageDoc.PageInfo.FullName); if (string.IsNullOrEmpty(pageNamespace)) { pageNamespace = null; } if (pageNamespace == nspace) { result.Add(pageDoc.PageInfo); } } } // Search page names for matches List <PageInfo> allPages = Pages.GetPages(Pages.FindNamespace(nspace)); var comp = new PageNameComparer(); var currentName = name.ToLowerInvariant(); foreach (PageInfo page in allPages) { if (NameTools.GetLocalName(page.FullName).ToLowerInvariant().Contains(currentName)) { if (result.Find(delegate(PageInfo p) { return(comp.Compare(p, page) == 0); }) == null) { result.Add(page); } } } return(result.ToArray()); }
/// <summary> /// Refreshes the bulk category list. /// </summary> private void RefreshBulkCategoryList() { lstBulkCategories.Items.Clear(); string cp = providerSelector.SelectedProvider; NamespaceInfo nspace = Pages.FindNamespace(lstNamespace.SelectedValue); var categories = from c in Pages.GetCategories(nspace) where c.Provider.GetType().FullName == cp select c; foreach (CategoryInfo cat in categories) { ListItem item = new ListItem(NameTools.GetLocalName(cat.FullName), cat.FullName); lstBulkCategories.Items.Add(item); } }
/// <summary> /// Finds all the Navigation Paths that include a Page. /// </summary> /// <param name="page">The Page.</param> /// <returns>The list of Navigation Paths.</returns> public static string[] PathsPerPage(PageInfo page) { NamespaceInfo pageNamespace = Pages.FindNamespace(NameTools.GetNamespace(page.FullName)); var result = new List <string>(10); List <NavigationPath> allPaths = GetNavigationPaths(pageNamespace); for (var i = 0; i < allPaths.Count; i++) { var pages = new List <string>(allPaths[i].Pages); if (pages.Contains(page.FullName)) { result.Add(allPaths[i].FullName); } } return(result.ToArray()); }