/// <summary> /// Adds some ACL entries for a subject. /// </summary> /// <param name="subject">The subject.</param> /// <param name="page">The page.</param> /// <param name="grants">The granted actions.</param> /// <param name="denials">The denied actions.</param> /// <returns><c>true</c> if the operation succeeded, <c>false</c> otherwise.</returns> private bool AddAclEntriesForPage(string subject, string page, string[] grants, string[] denials) { bool isGroup = subject.StartsWith("G."); subject = subject.Substring(2); PageInfo currentPage = Pages.FindPage(page); UserGroup group = null; UserInfo user = null; if (isGroup) { group = Users.FindUserGroup(subject); } else { user = Users.FindUser(subject); } foreach (string action in grants) { bool done = false; if (isGroup) { done = AuthWriter.SetPermissionForPage(AuthStatus.Grant, currentPage, action, group); } else { done = AuthWriter.SetPermissionForPage(AuthStatus.Grant, currentPage, action, user); } if (!done) { return(false); } } foreach (string action in denials) { bool done = false; if (isGroup) { done = AuthWriter.SetPermissionForPage(AuthStatus.Deny, currentPage, action, group); } else { done = AuthWriter.SetPermissionForPage(AuthStatus.Deny, currentPage, action, user); } if (!done) { return(false); } } return(true); }
protected void btnPrivate_Click(object sender, EventArgs e) { string currentWiki = DetectWiki(); NamespaceInfo nspace = Pages.FindNamespace(currentWiki, txtCurrentNamespace.Value); RemoveAllPermissions(nspace); AuthWriter authWriter = new AuthWriter(Collectors.CollectorsBox.GetSettingsProvider(currentWiki)); // Set permissions authWriter.SetPermissionForNamespace(AuthStatus.Grant, nspace, Actions.FullControl, Users.FindUserGroup(currentWiki, Settings.GetAdministratorsGroup(currentWiki))); authWriter.SetPermissionForNamespace(AuthStatus.Grant, nspace, Actions.ForNamespaces.CreatePages, Users.FindUserGroup(currentWiki, Settings.GetUsersGroup(currentWiki))); authWriter.SetPermissionForNamespace(AuthStatus.Grant, nspace, Actions.ForNamespaces.ManageCategories, Users.FindUserGroup(currentWiki, Settings.GetUsersGroup(currentWiki))); authWriter.SetPermissionForNamespace(AuthStatus.Grant, nspace, Actions.ForNamespaces.PostDiscussion, Users.FindUserGroup(currentWiki, Settings.GetUsersGroup(currentWiki))); authWriter.SetPermissionForNamespace(AuthStatus.Grant, nspace, Actions.ForNamespaces.DownloadAttachments, Users.FindUserGroup(currentWiki, Settings.GetUsersGroup(currentWiki))); RefreshPermissionsManager(); }
/// <summary> /// Recursively moves permissions from the old (renamed) directory to the new one. /// </summary> /// <param name="oldDirectory">The old directory name.</param> /// <param name="newDirectory">The new directory name.</param> private void MovePermissions(string oldDirectory, string newDirectory) { if (!oldDirectory.StartsWith("/")) { oldDirectory = "/" + oldDirectory; } if (!oldDirectory.EndsWith("/")) { oldDirectory = oldDirectory + "/"; } if (!newDirectory.StartsWith("/")) { newDirectory = "/" + newDirectory; } if (!newDirectory.EndsWith("/")) { newDirectory = newDirectory + "/"; } foreach (string sub in provider.ListDirectories(oldDirectory)) { string subNew = newDirectory + sub.Substring(oldDirectory.Length); MovePermissions(sub, subNew); } AuthWriter.ClearEntriesForDirectory(provider, newDirectory); AuthWriter.ProcessDirectoryRenaming(provider, oldDirectory, newDirectory); }
protected void btnNormal_Click(object sender, EventArgs e) { NamespaceInfo nspace = Pages.FindNamespace(txtCurrentNamespace.Value); RemoveAllPermissions(nspace); // Set permissions AuthWriter.SetPermissionForNamespace(AuthStatus.Grant, nspace, Actions.FullControl, Users.FindUserGroup(Settings.AdministratorsGroup)); AuthWriter.SetPermissionForNamespace(AuthStatus.Grant, nspace, Actions.ForNamespaces.CreatePages, Users.FindUserGroup(Settings.UsersGroup)); AuthWriter.SetPermissionForNamespace(AuthStatus.Grant, nspace, Actions.ForNamespaces.ManageCategories, Users.FindUserGroup(Settings.UsersGroup)); AuthWriter.SetPermissionForNamespace(AuthStatus.Grant, nspace, Actions.ForNamespaces.PostDiscussion, Users.FindUserGroup(Settings.UsersGroup)); AuthWriter.SetPermissionForNamespace(AuthStatus.Grant, nspace, Actions.ForNamespaces.DownloadAttachments, Users.FindUserGroup(Settings.UsersGroup)); AuthWriter.SetPermissionForNamespace(AuthStatus.Grant, nspace, Actions.ForNamespaces.ReadPages, Users.FindUserGroup(Settings.AnonymousGroup)); AuthWriter.SetPermissionForNamespace(AuthStatus.Grant, nspace, Actions.ForNamespaces.ReadDiscussion, Users.FindUserGroup(Settings.AnonymousGroup)); AuthWriter.SetPermissionForNamespace(AuthStatus.Grant, nspace, Actions.ForNamespaces.DownloadAttachments, Users.FindUserGroup(Settings.AnonymousGroup)); RefreshPermissionsManager(); }
/// <summary> /// Sets file management permissions for the users or anonymous users group in the given wiki, importing version 2.0 values. /// </summary> /// <param name="wiki">The wiki.</param> /// <param name="group">The group.</param> /// <returns><c>true</c> if the operation succeeded, <c>false</c> otherwise.</returns> private static bool SetupFileManagementPermissions(string wiki, UserGroup group) { bool done = true; AuthWriter authWriter = new AuthWriter(Collectors.CollectorsBox.GetSettingsProvider(wiki)); if (Settings.GetUsersCanViewFiles(wiki)) { done &= authWriter.SetPermissionForNamespace(AuthStatus.Grant, null, Actions.ForNamespaces.DownloadAttachments, group); foreach (IFilesStorageProviderV60 prov in Collectors.CollectorsBox.FilesProviderCollector.GetAllProviders(wiki)) { done &= authWriter.SetPermissionForDirectory(AuthStatus.Grant, prov, "/", Actions.ForDirectories.DownloadFiles, group); } } if (Settings.GetUsersCanUploadFiles(wiki)) { done &= authWriter.SetPermissionForNamespace(AuthStatus.Grant, null, Actions.ForNamespaces.UploadAttachments, group); foreach (IFilesStorageProviderV60 prov in Collectors.CollectorsBox.FilesProviderCollector.GetAllProviders(wiki)) { done &= authWriter.SetPermissionForDirectory(AuthStatus.Grant, prov, "/", Actions.ForDirectories.UploadFiles, group); done &= authWriter.SetPermissionForDirectory(AuthStatus.Grant, prov, "/", Actions.ForDirectories.CreateDirectories, group); } } if (Settings.GetUsersCanDeleteFiles(wiki)) { done &= authWriter.SetPermissionForNamespace(AuthStatus.Grant, null, Actions.ForNamespaces.DeleteAttachments, group); foreach (IFilesStorageProviderV60 prov in Collectors.CollectorsBox.FilesProviderCollector.GetAllProviders(wiki)) { done &= authWriter.SetPermissionForDirectory(AuthStatus.Grant, prov, "/", Actions.ForDirectories.DeleteFiles, group); done &= authWriter.SetPermissionForDirectory(AuthStatus.Grant, prov, "/", Actions.ForDirectories.DeleteDirectories, group); } } return(done); }
/// <summary> /// Sets the default permissions for the administrators group, properly importing version 2.0 values. /// </summary> /// <param name="administrators">The administrators group.</param> /// <returns><c>true</c> if the operation succeeded, <c>false</c> otherwise.</returns> public static bool SetAdministratorsGroupDefaultPermissions(UserGroup administrators) { // Administrators can do any operation return(AuthWriter.SetPermissionForGlobals(AuthStatus.Grant, Actions.FullControl, administrators)); // Settings.ConfigVisibleToAdmins is not imported on purpose }
protected void btnNewDirectory_Click(object sender, EventArgs e) { if (canCreateDirs) { txtNewDirectoryName.Text = txtNewDirectoryName.Text.Trim(); lblNewDirectoryResult.Text = ""; txtNewDirectoryName.Text = txtNewDirectoryName.Text.Trim('/'); AuthWriter.ClearEntriesForDirectory(provider, CurrentDirectory + txtNewDirectoryName.Text + "/"); bool done = provider.CreateDirectory(CurrentDirectory, txtNewDirectoryName.Text); if (!done) { lblNewDirectoryResult.CssClass = "resulterror"; lblNewDirectoryResult.Text = Properties.Messages.CannotCreateNewDirectory; } else { txtNewDirectoryName.Text = ""; Host.Instance.OnDirectoryActivity(provider.GetType().FullName, CurrentDirectory + txtNewDirectoryName.Text + "/", null, FileActivity.DirectoryCreated); } rptItems.DataBind(); } }
/// <summary> /// Sets file management permissions for the users or anonymous users group, importing version 2.0 values. /// </summary> /// <param name="group">The group.</param> /// <returns><c>true</c> if the operation succeeded, <c>false</c> otherwise.</returns> private static bool SetupFileManagementPermissions(UserGroup group) { bool done = true; if (Settings.UsersCanViewFiles) { done &= AuthWriter.SetPermissionForNamespace(AuthStatus.Grant, null, Actions.ForNamespaces.DownloadAttachments, group); foreach (IFilesStorageProviderV30 prov in Collectors.FilesProviderCollector.AllProviders) { done &= AuthWriter.SetPermissionForDirectory(AuthStatus.Grant, prov, "/", Actions.ForDirectories.DownloadFiles, group); } } if (Settings.UsersCanUploadFiles) { done &= AuthWriter.SetPermissionForNamespace(AuthStatus.Grant, null, Actions.ForNamespaces.UploadAttachments, group); foreach (IFilesStorageProviderV30 prov in Collectors.FilesProviderCollector.AllProviders) { done &= AuthWriter.SetPermissionForDirectory(AuthStatus.Grant, prov, "/", Actions.ForDirectories.UploadFiles, group); done &= AuthWriter.SetPermissionForDirectory(AuthStatus.Grant, prov, "/", Actions.ForDirectories.CreateDirectories, group); } } if (Settings.UsersCanDeleteFiles) { done &= AuthWriter.SetPermissionForNamespace(AuthStatus.Grant, null, Actions.ForNamespaces.DeleteAttachments, group); foreach (IFilesStorageProviderV30 prov in Collectors.FilesProviderCollector.AllProviders) { done &= AuthWriter.SetPermissionForDirectory(AuthStatus.Grant, prov, "/", Actions.ForDirectories.DeleteFiles, group); done &= AuthWriter.SetPermissionForDirectory(AuthStatus.Grant, prov, "/", Actions.ForDirectories.DeleteDirectories, group); } } return(done); }
/// <summary> /// Adds some ACL entries for a subject. /// </summary> /// <param name="subject">The subject.</param> /// <param name="provider">The provider.</param> /// <param name="directory">The directory.</param> /// <param name="grants">The granted actions.</param> /// <param name="denials">The denies actions.</param> /// <returns><c>true</c> if the operation succeeded, <c>false</c> otherwise.</returns> private bool AddAclEntriesForDirectory(string subject, IFilesStorageProviderV40 provider, string directory, string[] grants, string[] denials) { bool isGroup = subject.StartsWith("G."); subject = subject.Substring(2); UserGroup group = null; UserInfo user = null; if (isGroup) { group = Users.FindUserGroup(currentWiki, subject); } else { user = Users.FindUser(currentWiki, subject); } AuthWriter authWriter = new AuthWriter(Collectors.CollectorsBox.GetSettingsProvider(currentWiki)); foreach (string action in grants) { bool done = false; if (isGroup) { done = authWriter.SetPermissionForDirectory(AuthStatus.Grant, provider, directory, action, group); } else { done = authWriter.SetPermissionForDirectory(AuthStatus.Grant, provider, directory, action, user); } if (!done) { return(false); } } foreach (string action in denials) { bool done = false; if (isGroup) { done = authWriter.SetPermissionForDirectory(AuthStatus.Deny, provider, directory, action, group); } else { done = authWriter.SetPermissionForDirectory(AuthStatus.Deny, provider, directory, action, user); } if (!done) { return(false); } } return(true); }
/// <summary> /// Sets the default permissions for the users group in the given wiki, properly importing version 2.0 values. /// </summary> /// <param name="wiki">The wiki.</param> /// <param name="users">The users group.</param> /// <returns><c>true</c> if the operation succeeded, <c>false</c> otherwise.</returns> public static bool SetUsersGroupDefaultPermissions(string wiki, UserGroup users) { bool done = true; // Set namespace-related permissions AuthWriter authWriter = new AuthWriter(Collectors.CollectorsBox.GetSettingsProvider(wiki)); if (Settings.GetUsersCanCreateNewPages(wiki)) { done &= authWriter.SetPermissionForNamespace(AuthStatus.Grant, null, Actions.ForNamespaces.CreatePages, users); } else { done &= authWriter.SetPermissionForNamespace(AuthStatus.Grant, null, Actions.ForNamespaces.ModifyPages, users); } done &= authWriter.SetPermissionForNamespace(AuthStatus.Grant, null, Actions.ForNamespaces.PostDiscussion, users); if (Settings.GetUsersCanCreateNewCategories(wiki) || Settings.GetUsersCanManagePageCategories(wiki)) { done &= authWriter.SetPermissionForNamespace(AuthStatus.Grant, null, Actions.ForNamespaces.ManageCategories, users); } done &= SetupFileManagementPermissions(wiki, users); return(done); }
/// <summary> /// Removes all the permissions for a page. /// </summary> /// <param name="pageFullName">The page full name.</param> private void RemoveAllPermissions(string pageFullName) { AuthWriter authWriter = new AuthWriter(Collectors.CollectorsBox.GetSettingsProvider(currentWiki)); authWriter.RemoveEntriesForPage(Users.FindUserGroup(currentWiki, Settings.GetAnonymousGroup(currentWiki)), pageFullName); authWriter.RemoveEntriesForPage(Users.FindUserGroup(currentWiki, Settings.GetUsersGroup(currentWiki)), pageFullName); authWriter.RemoveEntriesForPage(Users.FindUserGroup(currentWiki, Settings.GetAdministratorsGroup(currentWiki)), pageFullName); }
/// <summary> /// Sets the default permissions for the administrators group, properly importing version 2.0 values. /// </summary> /// <param name="wiki">The wiki.</param> /// <param name="administrators">The administrators group.</param> /// <returns><c>true</c> if the operation succeeded, <c>false</c> otherwise.</returns> public static bool SetAdministratorsGroupDefaultPermissions(string wiki, UserGroup administrators) { // Administrators can do any operation AuthWriter authWriter = new AuthWriter(Collectors.CollectorsBox.GetSettingsProvider(wiki)); return(authWriter.SetPermissionForGlobals(AuthStatus.Grant, Actions.FullControl, administrators)); // Settings.ConfigVisibleToAdmins is not imported on purpose }
/// <summary> /// Removes all the permissions for a namespace. /// </summary> /// <param name="nspace">The namespace (<c>null</c> for the root).</param> private void RemoveAllPermissions(NamespaceInfo nspace) { string currentWiki = DetectWiki(); AuthWriter authWriter = new AuthWriter(Collectors.CollectorsBox.GetSettingsProvider(currentWiki)); authWriter.RemoveEntriesForNamespace(Users.FindUserGroup(currentWiki, Settings.GetAnonymousGroup(currentWiki)), nspace); authWriter.RemoveEntriesForNamespace(Users.FindUserGroup(currentWiki, Settings.GetUsersGroup(currentWiki)), nspace); authWriter.RemoveEntriesForNamespace(Users.FindUserGroup(currentWiki, Settings.GetAdministratorsGroup(currentWiki)), nspace); }
/// <summary> /// Deletes the permissions of a directory. /// </summary> /// <param name="provider">The provider.</param> /// <param name="directory">The directory.</param> private static void DeletePermissions(IFilesStorageProviderV30 provider, string directory) { directory = NormalizeFullPath(directory); foreach (string sub in provider.ListDirectories(directory)) { DeletePermissions(provider, sub); } AuthWriter.ClearEntriesForDirectory(provider, directory); }
/// <summary> /// Deletes the permissions of a directory. /// </summary> /// <param name="provider">The provider.</param> /// <param name="directory">The directory.</param> private static void DeletePermissions(IFilesStorageProviderV40 provider, string directory) { directory = NormalizeFullPath(directory); foreach (string sub in provider.ListDirectories(directory)) { DeletePermissions(provider, sub); } AuthWriter authWriter = new AuthWriter(Collectors.CollectorsBox.GetSettingsProvider(provider.CurrentWiki)); authWriter.ClearEntriesForDirectory(provider, directory); }
protected void btnPublic_Click(object sender, EventArgs e) { string page = txtCurrentPage.Value; AuthWriter authWriter = new AuthWriter(Collectors.CollectorsBox.GetSettingsProvider(currentWiki)); // Set permissions authWriter.SetPermissionForPage(AuthStatus.Grant, page, Actions.ForPages.ModifyPage, Users.FindUserGroup(currentWiki, Settings.GetAnonymousGroup(currentWiki))); authWriter.SetPermissionForPage(AuthStatus.Grant, page, Actions.ForPages.PostDiscussion, Users.FindUserGroup(currentWiki, Settings.GetAnonymousGroup(currentWiki))); RefreshPermissionsManager(); }
/// <summary> /// Removes all the ACL entries for a subject. /// </summary> /// <param name="subject">The subject.</param> /// <param name="provider">The provider.</param> /// <param name="directory">The directory.</param> /// <returns><c>true</c> if the operation succeeded, <c>false</c> otherwise.</returns> private bool RemoveAllAclEntriesForDirectory(string subject, IFilesStorageProviderV30 provider, string directory) { bool isGroup = lstSubjects.SelectedValue.StartsWith("G."); subject = subject.Substring(2); if (isGroup) { return(AuthWriter.RemoveEntriesForDirectory( Users.FindUserGroup(subject), provider, directory)); } return(AuthWriter.RemoveEntriesForDirectory( Users.FindUser(subject), provider, directory)); }
protected void btnLocked_Click(object sender, EventArgs e) { PageInfo page = Pages.FindPage(txtCurrentPage.Value); RemoveAllPermissions(page); // Set permissions AuthWriter.SetPermissionForPage(AuthStatus.Deny, page, Actions.ForPages.ModifyPage, Users.FindUserGroup(Settings.UsersGroup)); AuthWriter.SetPermissionForPage(AuthStatus.Deny, page, Actions.ForPages.ModifyPage, Users.FindUserGroup(Settings.AnonymousGroup)); RefreshPermissionsManager(); }
/// <summary> /// Removes all the ACL entries for a subject. /// </summary> /// <param name="subject">The subject.</param> /// <param name="nspace">The namespace (<c>null</c> for the root).</param> /// <returns><c>true</c> if the operation succeeded, <c>false</c> otherwise.</returns> private bool RemoveAllAclEntriesForNamespace(string subject, string nspace) { bool isGroup = lstSubjects.SelectedValue.StartsWith("G."); subject = subject.Substring(2); NamespaceInfo namespaceInfo = Pages.FindNamespace(nspace); if (isGroup) { return(AuthWriter.RemoveEntriesForNamespace( Users.FindUserGroup(subject), namespaceInfo)); } return(AuthWriter.RemoveEntriesForNamespace( Users.FindUser(subject), namespaceInfo)); }
/// <summary> /// Removes all the ACL entries for a subject. /// </summary> /// <param name="subject">The subject.</param> /// <param name="page">The page.</param> /// <returns><c>true</c> if the operation succeeded, <c>false</c> otherwise.</returns> private bool RemoveAllAclEntriesForPage(string subject, string page) { bool isGroup = lstSubjects.SelectedValue.StartsWith("G."); subject = subject.Substring(2); PageInfo currentPage = Pages.FindPage(page); if (isGroup) { return(AuthWriter.RemoveEntriesForPage( Users.FindUserGroup(subject), currentPage)); } return(AuthWriter.RemoveEntriesForPage( Users.FindUser(subject), currentPage)); }
/// <summary> /// Deletes the permissions of a directory. /// </summary> /// <param name="directory">The directory.</param> private void DeletePermissions(string directory) { if (!directory.StartsWith("/")) { directory = "/" + directory; } if (!directory.EndsWith("/")) { directory = directory + "/"; } foreach (string sub in provider.ListDirectories(directory)) { DeletePermissions(sub); } AuthWriter.ClearEntriesForDirectory(provider, directory); }
/// <summary> /// Sets the default permissions for the anonymous users group in the given wiki, properly importing version 2.0 values. /// </summary> /// <param name="wiki">The wiki.</param> /// <param name="anonymous">The anonymous users group.</param> /// <returns><c>true</c> if the operation succeeded, <c>false</c> otherwise.</returns> public static bool SetAnonymousGroupDefaultPermissions(string wiki, UserGroup anonymous) { bool done = true; AuthWriter authWriter = new AuthWriter(Collectors.CollectorsBox.GetSettingsProvider(wiki)); // Properly import Private/Public Mode wiki if (Settings.GetPrivateAccess(wiki)) { // Nothing to do, because without any explicit grant, Anonymous users cannot do anything } else if (Settings.GetPublicAccess(wiki)) { // Public access, allow modification and propagate file management permissions if they were allowed for anonymous users done &= authWriter.SetPermissionForNamespace(AuthStatus.Grant, null, Actions.ForNamespaces.ModifyPages, anonymous); done &= authWriter.SetPermissionForNamespace(AuthStatus.Grant, null, Actions.ForNamespaces.DownloadAttachments, anonymous); if (Settings.GetUsersCanCreateNewPages(wiki)) { done &= authWriter.SetPermissionForNamespace(AuthStatus.Grant, null, Actions.ForNamespaces.CreatePages, anonymous); } if (Settings.GetUsersCanCreateNewCategories(wiki) || Settings.GetUsersCanManagePageCategories(wiki)) { done &= authWriter.SetPermissionForNamespace(AuthStatus.Grant, null, Actions.ForNamespaces.ManageCategories, anonymous); } if (Settings.GetFileManagementInPublicAccessAllowed(wiki)) { SetupFileManagementPermissions(wiki, anonymous); } } else { // Standard configuration, only allow read permissions done &= authWriter.SetPermissionForNamespace(AuthStatus.Grant, null, Actions.ForNamespaces.ReadPages, anonymous); done &= authWriter.SetPermissionForNamespace(AuthStatus.Grant, null, Actions.ForNamespaces.ReadDiscussion, anonymous); done &= authWriter.SetPermissionForNamespace(AuthStatus.Grant, null, Actions.ForNamespaces.DownloadAttachments, anonymous); foreach (IFilesStorageProviderV60 prov in Collectors.CollectorsBox.FilesProviderCollector.GetAllProviders(wiki)) { done &= authWriter.SetPermissionForDirectory(AuthStatus.Grant, prov, "/", Actions.ForDirectories.DownloadFiles, anonymous); } } return(done); }
/// <summary> /// Removes all the ACL entries for a subject. /// </summary> /// <param name="subject">The subject.</param> /// <param name="provider">The provider.</param> /// <param name="directory">The directory.</param> /// <returns><c>true</c> if the operation succeeded, <c>false</c> otherwise.</returns> private bool RemoveAllAclEntriesForDirectory(string subject, IFilesStorageProviderV40 provider, string directory) { bool isGroup = lstSubjects.SelectedValue.StartsWith("G."); subject = subject.Substring(2); AuthWriter authWriter = new AuthWriter(Collectors.CollectorsBox.GetSettingsProvider(currentWiki)); if (isGroup) { return(authWriter.RemoveEntriesForDirectory( Users.FindUserGroup(currentWiki, subject), provider, directory)); } else { return(authWriter.RemoveEntriesForDirectory( Users.FindUser(currentWiki, subject), provider, directory)); } }
/// <summary> /// Imports version 2.0 page discussion settings and properly propagates them to user groups and single pages, when needed, for the given wiki. /// </summary> /// <param name="wiki">The wiki.</param> /// <returns><c>true</c> if the operation succeeded, <c>false</c> otherwise.</returns> private static bool ImportPageDiscussionPermissions(string wiki) { // Notes // Who can read pages, can read discussions // Who can modify pages, can post messages and read discussions // Who can manage pages, can manage discussions and post messages // Possible values: page|normal|locked|public string value = Settings.GetDiscussionPermissions(wiki).ToLowerInvariant(); UserGroup usersGroup = Users.FindUserGroup(wiki, Settings.GetUsersGroup(wiki)); UserGroup anonymousGroup = Users.FindUserGroup(wiki, Settings.GetAnonymousGroup(wiki)); bool done = true; AuthWriter authWriter = new AuthWriter(Collectors.CollectorsBox.GetSettingsProvider(wiki)); switch (value) { case "page": // Nothing to do break; case "normal": // Allow Users to post messages done &= authWriter.SetPermissionForNamespace(AuthStatus.Grant, null, Actions.ForNamespaces.PostDiscussion, usersGroup); break; case "locked": // Deny Users to post messages done &= authWriter.SetPermissionForNamespace(AuthStatus.Deny, null, Actions.ForNamespaces.PostDiscussion, usersGroup); break; case "public": // Allow Users and Anonymous Users to post messages done &= authWriter.SetPermissionForNamespace(AuthStatus.Grant, null, Actions.ForNamespaces.PostDiscussion, usersGroup); done &= authWriter.SetPermissionForNamespace(AuthStatus.Grant, null, Actions.ForNamespaces.PostDiscussion, anonymousGroup); break; } return(true); }
/// <summary> /// Removes all the ACL entries for a subject. /// </summary> /// <param name="subject">The subject.</param> /// <param name="nspace">The namespace (<c>null</c> for the root).</param> /// <returns><c>true</c> if the operation succeeded, <c>false</c> otherwise.</returns> private bool RemoveAllAclEntriesForNamespace(string subject, string nspace) { bool isGroup = lstSubjects.SelectedValue.StartsWith("G."); subject = subject.Substring(2); NamespaceInfo namespaceInfo = Pages.FindNamespace(currentWiki, nspace); AuthWriter authWriter = new AuthWriter(Collectors.CollectorsBox.GetSettingsProvider(currentWiki)); if (isGroup) { return(authWriter.RemoveEntriesForNamespace( Users.FindUserGroup(currentWiki, subject), namespaceInfo)); } else { return(authWriter.RemoveEntriesForNamespace( Users.FindUser(currentWiki, subject), namespaceInfo)); } }
/// <summary> /// Imports version 2.0 page discussion settings and properly propagates them to user groups and single pages, when needed. /// </summary> /// <returns><c>true</c> if the operation succeeded, <c>false</c> otherwise.</returns> private static bool ImportPageDiscussionPermissions() { // Notes // Who can read pages, can read discussions // Who can modify pages, can post messages and read discussions // Who can manage pages, can manage discussions and post messages // Possible values: page|normal|locked|public var value = Settings.DiscussionPermissions.ToLowerInvariant(); UserGroup usersGroup = Users.FindUserGroup(Settings.UsersGroup); UserGroup anonymousGroup = Users.FindUserGroup(Settings.AnonymousGroup); var done = true; switch (value) { case "page": // Nothing to do break; case "normal": // Allow Users to post messages done &= AuthWriter.SetPermissionForNamespace(AuthStatus.Grant, null, Actions.ForNamespaces.PostDiscussion, usersGroup); break; case "locked": // Deny Users to post messages done &= AuthWriter.SetPermissionForNamespace(AuthStatus.Deny, null, Actions.ForNamespaces.PostDiscussion, usersGroup); break; case "public": // Allow Users and Anonymous Users to post messages done &= AuthWriter.SetPermissionForNamespace(AuthStatus.Grant, null, Actions.ForNamespaces.PostDiscussion, usersGroup); done &= AuthWriter.SetPermissionForNamespace(AuthStatus.Grant, null, Actions.ForNamespaces.PostDiscussion, anonymousGroup); break; } return(true); }
/// <summary> /// Recursively moves permissions from the old (renamed) directory to the new one. /// </summary> /// <param name="provider">The provider.</param> /// <param name="oldDirectory">The old directory.</param> /// <param name="newDirectory">The new directory.</param> private static void MovePermissions(IFilesStorageProviderV30 provider, string oldDirectory, string newDirectory) { oldDirectory = NormalizeFullPath(oldDirectory); newDirectory = NormalizeFullPath(newDirectory); // At this point the directory has been already renamed, // thus we must list on the new directory and construct the old name // Example: /directory/one/ renamed to /directory/two-two/ // List on /directory/two-two/ // dir1 // dir2 // oldSub = /directory/one/dir1/ foreach (string sub in provider.ListDirectories(newDirectory)) { string oldSub = oldDirectory + sub.Substring(newDirectory.Length); MovePermissions(provider, oldSub, sub); } AuthWriter.ClearEntriesForDirectory(provider, newDirectory); AuthWriter.ProcessDirectoryRenaming(provider, oldDirectory, newDirectory); }
/// <summary> /// Adds some ACL entries for a group. /// </summary> /// <param name="group">The group.</param> /// <param name="grants">The granted actions.</param> /// <param name="denials">The denied actions.</param> /// <returns><c>true</c> if the operation succeeded, <c>false</c> otherwise.</returns> private bool AddAclEntries(UserGroup group, string[] grants, string[] denials) { foreach (string action in grants) { bool done = AuthWriter.SetPermissionForGlobals(AuthStatus.Grant, action, group); if (!done) { return(false); } } foreach (string action in denials) { bool done = AuthWriter.SetPermissionForGlobals(AuthStatus.Deny, action, group); if (!done) { return(false); } } return(true); }
/// <summary> /// Sets the default permissions for the users group, properly importing version 2.0 values. /// </summary> /// <param name="users">The users group.</param> /// <returns><c>true</c> if the operation succeeded, <c>false</c> otherwise.</returns> public static bool SetUsersGroupDefaultPermissions(UserGroup users) { bool done = true; // Set namespace-related permissions if (Settings.UsersCanCreateNewPages) { done &= AuthWriter.SetPermissionForNamespace(AuthStatus.Grant, null, Actions.ForNamespaces.CreatePages, users); } else { done &= AuthWriter.SetPermissionForNamespace(AuthStatus.Grant, null, Actions.ForNamespaces.ModifyPages, users); } done &= AuthWriter.SetPermissionForNamespace(AuthStatus.Grant, null, Actions.ForNamespaces.PostDiscussion, users); if (Settings.UsersCanCreateNewCategories || Settings.UsersCanManagePageCategories) { done &= AuthWriter.SetPermissionForNamespace(AuthStatus.Grant, null, Actions.ForNamespaces.ManageCategories, users); } done &= SetupFileManagementPermissions(users); return(done); }
protected void btnNewDirectory_Click(object sender, EventArgs e) { if (canCreateDirs) { txtNewDirectoryName.Text = txtNewDirectoryName.Text.Trim(); lblNewDirectoryResult.Text = ""; txtNewDirectoryName.Text = txtNewDirectoryName.Text.Trim('/'); AuthWriter authWriter = new AuthWriter(Collectors.CollectorsBox.GetSettingsProvider(currentWiki)); authWriter.ClearEntriesForDirectory(provider, CurrentDirectory + txtNewDirectoryName.Text + "/"); bool done = FilesAndAttachments.CreateDirectory(provider, CurrentDirectory, txtNewDirectoryName.Text); if (!done) { lblNewDirectoryResult.CssClass = "resulterror"; lblNewDirectoryResult.Text = Properties.Messages.CannotCreateNewDirectory; } else { txtNewDirectoryName.Text = ""; } rptItems.DataBind(); } }