public void AddUserToRole(string username, string role) { var roles = _provider.GetAllRoles(); _provider.RemoveUsersFromRoles(new string[] { username }, roles); _provider.AddUsersToRoles(new string[] { username }, new string[] { role }); }
public void TakeAwayFromSpecialUserTest() { if (rp.IsUserInRole(specialUN, specialRN)) { rp.RemoveUsersFromRoles(new[] { specialUN }, new[] { specialRN }); } Assert.IsFalse(rp.IsUserInRole(specialUN, specialRN)); }
public override void RemoveUsersFromRoles(string[] usernames, string[] roleNames) { if (!Initialized) { _prevProvider.RemoveUsersFromRoles(usernames, roleNames); } else { if (usernames.Where(username => string.IsNullOrEmpty(username)).Count() > 0 || usernames.Where(username => string.IsNullOrEmpty(username)).Count() > 0) { throw new ArgumentException(Resources.InvalidArrayValue); } using (MySqlDatabaseWrapper dbConn = new MySqlDatabaseWrapper(ConnectionString)) { foreach (var userid in GetUsersId(usernames)) { foreach (var roleid in GetRolesId(roleNames)) { if (userid > 0 && roleid > 0) { dbConn.ExecuteNonQuery(string.Format("delete from {0} where userid=? and roleid=?;", _userInRolesTable), userid, roleid); } } } } } }
internal static void CreateRoles(RoleProvider provider) { ProviderRoles = provider.GetAllRoles().ToList <string>().FindAll(roleName => roleName.ToLower().Contains("test_")); foreach (string role in ProviderRoles) { if (provider.RoleExists(role)) { string[] usersInRoles = provider.GetUsersInRole(role); if (usersInRoles.Length != 0) { provider.RemoveUsersFromRoles(usersInRoles, new string[] { role }); //remove users from role } provider.DeleteRole(role, false); //remove role } } ProviderRoles.Clear(); for (int x = 0; x < 20; x++) { string roleName = string.Format("TEST_ROLE:{0:000}", x); ProviderRoles.Add(roleName); provider.CreateRole(roleName); } //NOTE: roles 0-9 are reserved for query type operations and should be considered read only // roles 10-19 may be used for C-U-D operations addUserToRole(Users[0], ProviderRoles[0], provider); // several users in one role addUserToRole(Users[2], ProviderRoles[0], provider); addUserToRole(Users[4], ProviderRoles[0], provider); addUserToRole(Users[6], ProviderRoles[1], provider); // same user in multiple roles addUserToRole(Users[6], ProviderRoles[2], provider); addUserToRole(Users[6], ProviderRoles[3], provider); addUserToRole(Users[10], ProviderRoles[1], provider); // same user in multiple roles addUserToRole(Users[10], ProviderRoles[2], provider); addUserToRole(Users[10], ProviderRoles[3], provider); addUserToRole(Users[8], ProviderRoles[1], provider); addUserToRole(Users[8], ProviderRoles[2], provider); /* * TEST_ROLE:000 * Users[0] * Users[2] * Users[4] * TEST_ROLE:001 * Users[6] * Users[8] * TEST_ROLE:002 * Users[6] * Users[8] * TEST_ROLE:003 * Users[6] * TEST_ROLE:004 * -- no users * */ }
public void AddRemoveRoleForUser(string username, string rolename, bool isInRole) { if (isInRole) { _roleProvider.AddUsersToRoles(new string[] { username }, new string[] { rolename }); } else { _roleProvider.RemoveUsersFromRoles(new string[] { username }, new string[] { rolename }); } }
public void RemoveUserFromFole(User user, Role role, RoleProvider cfrp) { var rolesList = user.Roles.Select(a => a.RoleName).ToList(); var userRoles = Context.Roles.Where(x => rolesList.Contains(role.RoleName)).ToList(); var foundRole = !userRoles.Contains(role); if (foundRole) { Roles.RemoveUserFromRole(user.Username, role.RoleName); cfrp.RemoveUsersFromRoles(new[] { user.Username }, new[] { role.RoleName }); } }
private void ResetRoles(string userName) { string[] users = { userName }; foreach (var role in _roleProvider.GetRolesForUser(userName)) { if (_roleProvider.IsUserInRole(userName, role)) { string[] roles = { role }; _roleProvider.RemoveUsersFromRoles(users, roles); } } }
public override void RemoveUsersFromRoles(string[] usernames, string[] roleNames) { LogDebug("Entering CachedProvider.RemoveUsersFromRoles"); foreach (string username in usernames) { if (_cache.Contains(username)) { List <string> roles = (List <string>)_cache[username]; foreach (string role in roleNames) { roles.Remove(role); } } } _provider.RemoveUsersFromRoles(usernames, roleNames); }
public void UpdateUser(MembershipUser user, string[] roles) { using (var ts = new TransactionScope()) { _provider.UpdateUser(user); var existingRoles = _roleProvider.GetRolesForUser(user.UserName); if (roles != null && roles.Length > 0) { var rolesToBeAdded = roles.Except(existingRoles).ToArray(); _roleProvider.AddUsersToRoles(new[] { user.UserName }, rolesToBeAdded); } if (existingRoles.Length > 0) { var rolesToBeDeleted = (roles != null ? existingRoles.Except(roles) : existingRoles).ToArray(); _roleProvider.RemoveUsersFromRoles(new[] { user.UserName }, rolesToBeDeleted); } ts.Complete(); } }
public void Can_Remove_Users_From_Roles() { var user1 = new User { Username = "******", Password = "******" }; var user2 = new User { Username = "******", Password = "******" }; RoleProvider.CreateRole("admin"); RoleProvider.CreateRole("engineering"); RoleProvider.CreateRole("sales"); MembershipProvider.CreateAccount(user1); MembershipProvider.CreateAccount(user2); RoleProvider.AddUsersToRoles(new[] { "sallen", "missmm" }, new[] { "admin", "engineering" }); RoleProvider.RemoveUsersFromRoles(new[] { "sallen", "missmm" }, new[] { "sales", "admin" }); Assert.True(RoleProvider.IsUserInRole("sallen", "engineering")); Assert.False(RoleProvider.IsUserInRole("sallen", "admin")); }
public string Process(string[] args) { var sb = new StringBuilder(); var p = new OptionSet() { { "c|create", "create a role\nUSAGE: role --create rolename", v => _command = Command.Create }, { "d|delete", "delete a role\nUSAGE: role --delete rolename", v => _command = Command.Delete }, { "l|list", "return a list of roles\nUSAGE: role --list", v => _command = Command.List }, { "g|give", "add a user to a role\nUSAGE: role --give username rolename", v => _command = Command.Give }, { "t|take", "remove a user from a role\nUSAGE: role --take username rolename", v => _command = Command.Take }, { "u|users", "list all users in a role\nUSAGE: role --users rolename", v => _command = Command.Users }, { "r|roles", "list all roles for a user\nUSAGE: role --roles username", v => _command = Command.Roles }, { "h|help", "show this list of options\nUSAGE --help", v => _command = null } }; List <string> extras; try { extras = p.Parse(args); } catch (OptionException e) { sb.Append("role: "); sb.AppendLine(e.Message); sb.AppendLine("Try `role --help' for more information."); return(sb.ToString()); } // perform the selected command if (_command == Command.Create) { if (extras.Count == 1) { _provider.CreateRole(extras[0]); sb.AppendLine("Role successfully created"); } else { sb.AppendLine("USAGE: role --create rolename"); } } else if (_command == Command.Delete) { if (extras.Count == 1) { try { var success = _provider.DeleteRole(extras[0], true); if (success) { sb.AppendLine("Role successfully deleted"); } else { sb.AppendFormat("Could not delete role: {0}", extras[0]); sb.AppendLine(); } } catch (Exception ex) { sb.AppendFormat("Could not delete role: {0} - {1}", extras[0], ex.Message); sb.AppendLine(); } } else { sb.AppendLine("USAGE: role --delete rolename"); } } else if (_command == Command.List) { if (extras.Count == 0) { var roles = _provider.GetAllRoles(); if (roles.Count() > 0) { foreach (var role in roles) { sb.AppendLine(role); } } else { sb.AppendLine("No roles found"); } } else { sb.AppendLine("USAGE: role --list"); } } else if (_command == Command.Give) { if (extras.Count == 2) { _provider.AddUsersToRoles(new string[] { extras[0] }, new string[] { extras[1] }); sb.AppendFormat("Added {0} to {1}", extras[0], extras[1]); sb.AppendLine(); } else { sb.AppendLine("USAGE: role --give username rolename"); } } else if (_command == Command.Take) { if (extras.Count == 2) { _provider.RemoveUsersFromRoles(new string[] { extras[0] }, new string[] { extras[1] }); sb.AppendFormat("Removed {0} from {1}", extras[0], extras[1]); sb.AppendLine(); } else { sb.AppendLine("USAGE: role --take username rolename"); } } else if (_command == Command.Users) { if (extras.Count == 1) { var users = _provider.GetUsersInRole(extras[0]); if (users.Count() > 0) { sb.AppendFormat("{0} users in {1}", users.Count(), extras[0]); sb.AppendLine(); foreach (var u in users) { sb.AppendLine(u); } } else { sb.AppendLine("No users in role"); } } else { sb.AppendLine("USAGE: role --users rolename"); } } else if (_command == Command.Roles) { if (extras.Count == 1) { var roles = _provider.GetRolesForUser(extras[0]); if (roles.Count() > 0) { sb.AppendFormat("{0} roles for {1}", roles.Count(), extras[0]); sb.AppendLine(); foreach (var r in roles) { sb.AppendLine(r); } } else { sb.AppendLine("No roles found for user"); } } else { sb.AppendLine("USAGE: role --roles username"); } } else { sb.AppendLine(ShowHelp(p)); } return(sb.ToString()); }
public void RemoveUserFromRole(string userName, string roleName) { string[] userNames = new string[] { userName }; string[] roleNames = new string[] { roleName }; _provider.RemoveUsersFromRoles(userNames, roleNames); }
/// <summary> /// Removes from role. /// </summary> /// <param name="user">The user.</param> /// <param name="roleName">Name of the role.</param> public void RemoveFromRole(MembershipUser user, string roleName) { _roleProvider.RemoveUsersFromRoles(new[] { user.UserName }, new[] { roleName }); }
public void RemoveUsersFromRoles(string[] usernames, string[] roleNames) { _provider.RemoveUsersFromRoles(usernames, roleNames); }
public void RemoveUserFromRole(string username, string roleName) { roleProvider.RemoveUsersFromRoles(new string[] { username }, new string[] { roleName }); }
public static void RemoveUserFromRole(this RoleProvider roleProvider, string userName, string role) { roleProvider.RemoveUsersFromRoles(new[] { userName }, new[] { role }); }
public void RemoveUsersToRole(string[] users, string[] roles) { roleProvider.RemoveUsersFromRoles(users, roles); }
/// <summary> /// DeleteUserRole() Method <a name="DeleteUserRole"></a> /// The DeleteUserRole method deletes the user from the specified role. /// Other relevant sources: /// + <a href="DeleteUserRole.htm" style="color:green">DeleteUserRole Stored Procedure</a> /// </summary> /// <param name="roleID">The role ID.</param> /// <param name="userID">The user ID.</param> public void DeleteUserRole(Guid roleID, Guid userID) { RoleProvider.RemoveUsersFromRoles(CurrentPortalSettings.PortalAlias, new Guid[] { userID }, new Guid[] { roleID }); }
public void MembershipRole_RemoveUsersFromRolesTests() { string[] users = new string[] { TestUtils.Users[16].Username }; string[] roles = new string[] { }; //------------------------------------------------------- // empty role list, error //------------------------------------------------------- try { _provider.RemoveUsersFromRoles(users, roles); Assert.Fail("Provider did not throw expected ArgumentException on empty roleName list"); } catch (ArgumentException) { //ignore expected exception } //------------------------------------------------------- // empty user list, error //------------------------------------------------------- users = new string[] { }; roles = new string[] { TestUtils.ProviderRoles[0] }; try { _provider.RemoveUsersFromRoles(users, roles); Assert.Fail("Provider did not throw expected ArgumentException on empty users list"); } catch (ArgumentException) { //ignore expected exception } //------------------------------------------------------- // null user list, error //------------------------------------------------------- users = null; roles = new string[] { TestUtils.ProviderRoles[0] }; try { _provider.RemoveUsersFromRoles(users, roles); Assert.Fail("Provider did not throw expected ArgumentException on null user list"); } catch (ArgumentException) { //ignore expected exception } //------------------------------------------------------- // null role list, error //------------------------------------------------------- users = new string[] { TestUtils.Users[14].Username }; roles = null; try { _provider.RemoveUsersFromRoles(users, roles); Assert.Fail("Provider did not throw expected ArgumentNullException on null role list"); } catch (ArgumentNullException) { //ignore expected exception } //------------------------------------------------------- // remove existing user from exiting role //------------------------------------------------------- users = new string[] { TestUtils.Users[8].Username }; roles = new string[] { TestUtils.ProviderRoles[1] }; _provider.RemoveUsersFromRoles(users, roles); //------------------------------------------------------- // remove several users from existing roles, some users // not members of existing roles, error //------------------------------------------------------- users = new string[] { TestUtils.Users[4].Username, TestUtils.Users[6].Username }; roles = new string[] { TestUtils.ProviderRoles[0], TestUtils.ProviderRoles[3] }; try { _provider.RemoveUsersFromRoles(users, roles); Assert.Fail("Provider did not throw expected ProviderException"); } catch (ProviderException) { //ignore expected order } //------------------------------------------------------- // remove existing users from existing roles except one role is null //------------------------------------------------------- users = new string[] { TestUtils.Users[6].Username, TestUtils.Users[10].Username }; roles = new string[] { TestUtils.ProviderRoles[1], null }; try { _provider.RemoveUsersFromRoles(users, roles); Assert.Fail("Provider did not throw expected ArgumentNullException when one role is null in the list"); } catch (ArgumentNullException) { //ignore expected exception } //------------------------------------------------------- // remove existing users from existing roles except one role is empty //------------------------------------------------------- users = new string[] { TestUtils.Users[20].Username, TestUtils.Users[22].Username }; roles = new string[] { TestUtils.ProviderRoles[10], string.Empty }; try { _provider.RemoveUsersFromRoles(users, roles); Assert.Fail("Provider did not throw expected ArgumentException when one role is null in the list"); } catch (ArgumentException) { //ignore expected exception } //------------------------------------------------------- // remove existing users from existing roles except one role is non-existant //------------------------------------------------------- users = new string[] { TestUtils.Users[20].Username, TestUtils.Users[22].Username }; roles = new string[] { TestUtils.ProviderRoles[10], "TEST_" + Guid.NewGuid().ToString() }; try { _provider.RemoveUsersFromRoles(users, roles); Assert.Fail("Provider did not throw expected ProviderException when one role did not exist"); } catch (ProviderException) { //ignore expected exception } //------------------------------------------------------- // remove existing users (except one user is null) from existing roles //------------------------------------------------------- users = new string[] { TestUtils.Users[20].Username, null }; roles = new string[] { TestUtils.ProviderRoles[10], TestUtils.ProviderRoles[11] }; try { _provider.RemoveUsersFromRoles(users, roles); Assert.Fail("Provider did not throw expected ArgumentNull expception when one user is null"); } catch (ArgumentNullException) { //ignore expected exception } //------------------------------------------------------- // remove existing users (except one user is empty) from existing roles //------------------------------------------------------- users = new string[] { TestUtils.Users[20].Username, string.Empty }; roles = new string[] { TestUtils.ProviderRoles[10], TestUtils.ProviderRoles[11] }; try { _provider.RemoveUsersFromRoles(users, roles); } catch (ArgumentException) { //ignore expected exception } //------------------------------------------------------- // remove existing users from existing roles except one user // doesn't exist //------------------------------------------------------- users = new string[] { TestUtils.Users[20].Username, "TEST_" + Guid.NewGuid().ToString() }; roles = new string[] { TestUtils.ProviderRoles[10], TestUtils.ProviderRoles[11] }; try { _provider.RemoveUsersFromRoles(users, roles); } catch (ProviderException) { //ignore expected exception } //------------------------------------------------------- // remove existing user from existing roles except one user is not member of that role //------------------------------------------------------- users = new string[] { TestUtils.Users[30].Username, TestUtils.Users[6].Username }; roles = new string[] { TestUtils.ProviderRoles[6], TestUtils.ProviderRoles[10] }; try { _provider.RemoveUsersFromRoles(users, roles); } catch (ProviderException) { //ignore expected exception } //------------------------------------------------------- // duplicate rolenames in list //------------------------------------------------------- users = new string[] { TestUtils.Users[30].Username, TestUtils.Users[31].Username }; roles = new string[] { TestUtils.ProviderRoles[18], TestUtils.ProviderRoles[18] }; try { _provider.RemoveUsersFromRoles(users, roles); } catch (ArgumentException) { //ignore expected exception } //------------------------------------------------------- // duplicate users in list //------------------------------------------------------- users = new string[] { TestUtils.Users[30].Username, TestUtils.Users[30].Username }; roles = new string[] { TestUtils.ProviderRoles[18], TestUtils.ProviderRoles[19] }; try { _provider.RemoveUsersFromRoles(users, roles); } catch (ArgumentException) { //ignore expected exception } }