private MembershipCreateStatus?ObtainUser(string username, string roleName)
{
if (_membershipProvider.GetUser(username, false) != null)
{
if (!_roleProvider.IsUserInRole(username, roleName))
{
_roleProvider.AddUsersToRoles(new[] { username }, new[] { roleName });
}
return(null);
}
var status = ObtainUser(username);
_roleProvider.AddUsersToRoles(new[] { username }, new[] { roleName });
return(status);
}
public ActionResult Edit(int?ID)
{
var myRoles = DB.Roles.Where(x => CurrentUser.UserRoles.Contains(x.RoleName)).Select(x => x.RoleId).ToList();
var allowedRoles =
DB.UserAllowedRoles.Where(x => myRoles.Contains(x.RoleID))
.Select(x => DB.Roles.FirstOrDefault(z => z.RoleId == x.AllowedRoleID))
.Where(x => x != null)
.Distinct()
.ToList();
ViewBag.AllowedRoles = allowedRoles;
User user = null;
if (ID.HasValue)
{
user = DB.Users.FirstOrDefault(x => x.ID == ID);
if (user == null || ((user.IsDeleted ?? false) && RoleProvider.IsUserInRole(CurrentUser.Name, "Admin")))
{
return(RedirectToAction("Index"));
}
}
else
{
user = new User()
{
Password = new Random(DateTime.Now.Millisecond).GeneratePassword()
};
}
if (user.ID > 0)
{
user.UserRoleRadio = DB.Roles.First(x => x.RoleName == user.UserRoles.First()).RoleId;
}
return(View(user));
}
public void OnAuthorization(AuthorizationContext filterContext)
{
var user = filterContext.HttpContext.User;
if (!user.Identity.IsAuthenticated)
{
HandleUnauthorizedRequest(filterContext);
return;
}
if (_usersSplit.Length > 0)
{
if (_usersSplit.Contains(user.Identity.Name, StringComparer.OrdinalIgnoreCase))
{
return;
}
}
if (_rolesSplit.Length > 0)
{
if (_rolesSplit.Any(role => RoleProvider.IsUserInRole(user.Identity.Name, role)))
{
return;
}
}
if (_rolesSplit.Length > 0 || _usersSplit.Length > 0)
{
HandleUnauthorizedRequest(filterContext);
}
}
public override bool IsUserInRole(string username, string roleName)
{
if (!Initialized)
{
return(_prevProvider.IsUserInRole(username, roleName));
}
string connString = ConnectionString;
if (string.IsNullOrEmpty(username))
{
MySqlSimpleMembershipProvider.NullArgumentException("username");
}
if (string.IsNullOrEmpty(roleName))
{
MySqlSimpleMembershipProvider.NullArgumentException("roleName");
}
int userid = MySqlSimpleMembershipProvider.GetUserId(username, connString, UserTableName, UserIdColumn, UserNameColumn);
int roleid = GetRoleId(roleName);
if (userid <= 0 || roleid <= 0)
{
return(false);
}
using (MySqlDatabaseWrapper dbConn = new MySqlDatabaseWrapper(connString))
{
return((dbConn.ExecuteQuery(string.Format("select count(userid) from {0} where userid=? and roleid=?;", _userInRolesTable), userid, roleid)).Count() > 0);
}
}
public void IsUserInRole_GetRolesForUserAndCheckIfuserInAllRoles_RetrunsTrueForAllRoles()
{
var roles = provider.GetRolesForUser(ExistingUserName);
foreach (var role in roles)
{
Assert.IsTrue(provider.IsUserInRole(ExistingUserName, role), string.Format("User '{0}' is not in role '{1}'", ExistingUserName, role));
}
}
public bool IsInRole(string role)
{
RoleProvider roleProvider = (this.roleProvider as RoleProvider) ?? SystemWebHelper.GetDefaultRoleProvider();
if (roleProvider != null)
{
return(roleProvider.IsUserInRole(this.securityContext.PrimaryIdentity.Name, role));
}
return(false);
}
public void AssignSpecialRoleToSpecialUserTest()
{
if (!rp.RoleExists(specialRN))
{
CreateSpecialRoleTest();
}
rp.AddUsersToRoles(new[] { specialUN }, new[] { specialRN });
Assert.IsTrue(rp.IsUserInRole(specialUN, specialRN));
TakeAwayFromSpecialUserTest();
}
public bool IsUserInRole(string userName, string roleName)
{
if (String.IsNullOrEmpty(userName))
{
throw new ArgumentException("Value cannot be null or empty.", "userName");
}
if (String.IsNullOrEmpty(roleName))
{
throw new ArgumentException("Value cannot be null or empty.", "roleName");
}
return(_provider.IsUserInRole(userName, 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 void Can_Find_User_In_Role()
{
var user = new User {
Username = "******", Password = "******"
};
RoleProvider.CreateRole("admin");
MembershipProvider.CreateAccount(user);
RoleProvider.AddUsersToRoles(new[] { "sallen" }, new[] { "admin" });
Assert.True(RoleProvider.IsUserInRole("sallen", "admin"));
}
public override bool IsUserInRole(string username, string roleName)
{
LogDebug("Entering CachedProvider.IsUserInRole");
bool result;
List <string> roles;
if (_cache.ContainsKey(username))
{
roles = (List <string>)_cache[username];
result = roles.Contains(roleName);
if (!result)
{
result = _provider.IsUserInRole(username, roleName);
if (result)
{
roles.Add(roleName);
}
}
return(result);
}
result = _provider.IsUserInRole(username, roleName);
return(result);
}
public bool IsCurrentUserInRole(string role)
{
if (role == null)
{
throw new ArgumentNullException("role");
}
try {
ApplicationServiceHelper.EnsureRoleServiceEnabled();
EnsureProviderEnabled();
IPrincipal user = ApplicationServiceHelper.GetCurrentUser(HttpContext.Current);
string username = ApplicationServiceHelper.GetUserName(user);
RoleProvider provider = GetRoleProvider(user);
return(provider.IsUserInRole(username, role));
}
catch (Exception e) {
LogException(e);
throw;
}
}
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 override bool IsUserInRole(string username, string roleName)
{
return(_Provider.IsUserInRole(username, roleName));
}
/// <summary>
/// Determines whether [is in role] [the specified user].
/// </summary>
/// <param name="user">The user.</param>
/// <param name="roleName">Name of the role.</param>
/// <returns>
/// <c>true</c> if [is in role] [the specified user]; otherwise, <c>false</c>.
/// </returns>
public bool IsInRole(MembershipUser user, string roleName)
{
return(_roleProvider.IsUserInRole(user.UserName, roleName));
}
public void MembershipRole_IsUserInRoleTests()
{
string userName;
string roleName;
bool result;
//-------------------------------------------------------
// existing user in existing role
//-------------------------------------------------------
userName = TestUtils.Users[0].Username;
roleName = TestUtils.ProviderRoles[0];
result = _provider.IsUserInRole(userName, roleName);
Assert.AreEqual <bool>(true, result);
//-------------------------------------------------------
// existing user not in existing role
//-------------------------------------------------------
userName = TestUtils.Users[0].Username;
roleName = TestUtils.ProviderRoles[10];
result = _provider.IsUserInRole(userName, roleName);
Assert.AreEqual <bool>(false, result);
//-------------------------------------------------------
// existing user, non existing role
//-------------------------------------------------------
userName = TestUtils.Users[0].Username;
roleName = Guid.NewGuid().ToString();
result = _provider.IsUserInRole(userName, roleName);
Assert.IsFalse(result);
//-------------------------------------------------------
// non existing user, existing role
//-------------------------------------------------------
userName = Guid.NewGuid().ToString();
roleName = TestUtils.ProviderRoles[0];
result = _provider.IsUserInRole(userName, roleName);
Assert.IsFalse(result);
//-------------------------------------------------------
// existing user, roleName contains comma
//-------------------------------------------------------
userName = Guid.NewGuid().ToString();
roleName = TestUtils.ProviderRoles[0] + "," + TestUtils.ProviderRoles[1];
try
{
result = _provider.IsUserInRole(userName, roleName);
Assert.Fail("Provider did not throw expected ArugumentException");
}
catch (ArgumentException)
{
//ignore expected exception
}
//-------------------------------------------------------
// null user, valid role
//-------------------------------------------------------
userName = null;
roleName = TestUtils.ProviderRoles[0];
try
{
result = _provider.IsUserInRole(userName, roleName);
Assert.Fail("Provider did not throw expected ArgumentNullException");
}
catch (ArgumentNullException)
{
//ignore expected exception
}
//-------------------------------------------------------
// empty user, valid role
//-------------------------------------------------------
userName = string.Empty;
roleName = TestUtils.ProviderRoles[0];
try
{
result = _provider.IsUserInRole(userName, roleName);
Assert.Fail("Provider did not throw expected ArgumentException");
}
catch (ArgumentException)
{
//ignore expected exception
}
//-------------------------------------------------------
// valid user, null role
//-------------------------------------------------------
userName = TestUtils.Users[0].Username;
roleName = null;
try
{
result = _provider.IsUserInRole(userName, roleName);
Assert.Fail("Provider did not throw expected ArgumentNullException");
}
catch (ArgumentNullException)
{
//ignore expected exception
}
//-------------------------------------------------------
// valid user, empty role
//-------------------------------------------------------
userName = TestUtils.Users[0].Username;
roleName = string.Empty;
try
{
result = _provider.IsUserInRole(userName, roleName);
Assert.Fail("Provider did not throw expected ArgumentException");
}
catch (ArgumentException)
{
//ignore expected exception
}
}
/// <summary> Determines whether the current principal belongs to the specified role. </summary>
/// <remarks> ebrown, 1/3/2011. </remarks>
/// <param name="role"> The name of the role for which to check membership. </param>
/// <returns> true if the current principal is a member of the specified role; otherwise, false. </returns>
public bool IsInRole(string role)
{
return(_roleProvider.IsUserInRole(_identity.Name, role));
}
public bool IsUserInRole(string username, string roleName)
{
return(_roleProvider.IsUserInRole(username, roleName));
}
public bool IsUserInRole(string roleName)
{
return(roleProvider.IsUserInRole(null, roleName));
}
