public void MembershipRole_GetRolesForUserTests() { string[] results; string userName; //------------------------------------------------------- // existing user with roles //------------------------------------------------------- userName = TestUtils.Users[6].Username; results = _provider.GetRolesForUser(userName); Assert.IsNotNull(results); Assert.AreEqual(3, results.Length); Assert.AreEqual <string>(TestUtils.ProviderRoles[1], results[0]); Assert.AreEqual <string>(TestUtils.ProviderRoles[2], results[1]); Assert.AreEqual <string>(TestUtils.ProviderRoles[3], results[2]); //------------------------------------------------------- // existing user without roles //------------------------------------------------------- userName = TestUtils.Users[12].Username; results = _provider.GetRolesForUser(userName); Assert.IsNotNull(results); Assert.AreEqual(0, results.Length); //------------------------------------------------------- // null usernmae //------------------------------------------------------- userName = null; try { results = _provider.GetRolesForUser(userName); Assert.Fail("Provider did not throw expected ArgumentNullException"); } catch (ArgumentNullException) { //ignore expected exception } //------------------------------------------------------- // empty username //------------------------------------------------------- userName = string.Empty; try { results = _provider.GetRolesForUser(userName); Assert.Fail("Provider did not throw expected ArgumentException"); } catch (ArgumentException) { //ignore expected exception } }
public ActionResult Edit(Guid id) { if (id != User.Id() && !User.IsInRole(Definitions.Roles.Administrator)) { return(RedirectToAction("Unauthorized", "Home")); } if (MembershipService.IsReadOnly()) { return(RedirectToAction("Detail", "Account", new { id = id })); } var user = MembershipService.GetUserModel(id); if (user != null) { var model = new UserEditModel { Id = user.Id, Username = user.Username, Name = user.GivenName, Surname = user.Surname, Email = user.Email, Roles = RoleProvider.GetAllRoles(), SelectedRoles = RoleProvider.GetRolesForUser(user.Id) }; return(View(model)); } return(View()); }
/// <summary> /// The GetRoles method returns a list of roles for the user. /// </summary> /// <param name="email">The email.</param> /// <param name="portalAlias">The portal alias.</param> /// <returns>A <code>IList<RainbowRole></code> containing the user's roles</returns> public IList <RainbowRole> GetRoles(string email, string portalAlias) { string userName = MembershipProvider.GetUserNameByEmail(portalAlias, email); RainbowUser user = (RainbowUser)MembershipProvider.GetUser(portalAlias, userName, true); return(RoleProvider.GetRolesForUser(portalAlias, user.ProviderUserKey)); }
internal static bool HasAccess(this IPublicAccessService publicAccessService, int documentId, object providerUserKey, IContentService contentService, MembershipProvider membershipProvider, RoleProvider roleProvider) { var content = contentService.GetById(documentId); if (content == null) { return(true); } var entry = publicAccessService.GetEntryForContent(content); if (entry == null) { return(true); } var member = membershipProvider.GetUser(providerUserKey, false); if (member == null) { return(false); } var roles = roleProvider.GetRolesForUser(member.UserName); return(entry.Rules.Any(x => x.RuleType == Constants.Conventions.PublicAccess.MemberRoleRuleType && roles.Contains(x.RuleValue))); }
public ActionResult Edit(string id) { if (!id.Equals(User.Id(), StringComparison.OrdinalIgnoreCase) && !User.IsInRole(Definitions.Roles.Administrator)) { return(RedirectToAction("Unauthorized", "Home")); } if (MembershipService.IsReadOnly()) { return(RedirectToAction("Detail", "Account", new { id = id })); } if (!String.IsNullOrEmpty(id)) { var user = MembershipService.GetUser(id); if (user != null) { var model = new UserEditModel { Username = user.Name, Name = user.GivenName, Surname = user.Surname, Email = user.Email, Roles = RoleProvider.GetRolesForUser(user.Name), }; PopulateRoles(); return(View(model)); } } return(View()); }
public override string[] GetRolesForUser(string username) { if (!Initialized) { return(_prevProvider.GetRolesForUser(username)); } if (string.IsNullOrEmpty(username)) { MySqlSimpleMembershipProvider.NullArgumentException("username"); } string connString = ConnectionString; int userid = MySqlSimpleMembershipProvider.GetUserId(username, connString, UserTableName, UserIdColumn, UserNameColumn); if (userid > 0) { using (MySqlDatabaseWrapper dbConn = new MySqlDatabaseWrapper(connString)) { var roles = dbConn.ExecuteQuery(string.Format("select rt.rolename from {0} as urt join {1} as rt on urt.roleid = rt.roleid where urt.userid=?;", _userInRolesTable, _rolesTable), userid); if (roles.Count() > 0) { return(roles.Select(role => role[0].ToString()).ToArray()); } } } return(null); }
public static void AddUserToRolesIfNotInYet(this RoleProvider p, string username, List <string> roles) { string[] rsUserIn = p.GetRolesForUser(username); List <string> rsToAdd = new List <string>(); if (rsUserIn != null) { foreach (string role in roles) { if (!rsUserIn.Contains(role)) { rsToAdd.Add(role); } } } else { rsToAdd = roles; } if (rsToAdd.Count > 0) { Utils.BaseRoleProvider().AddUsersToRoles(new string[] { username }, rsToAdd.ToArray()); } }
public void RoleAttachTest1() { if (mp.GetUser(specialUN, false) == null) { CreateSpecialUser(); } string roleName = Guid.NewGuid().ToString().Replace("-", ""); rp.CreateRole(roleName); Assert.IsTrue(rp.RoleExists(roleName)); rp.AddUsersToRoles(new[] { specialUN }, new[] { roleName }); Assert.Contains(roleName, rp.GetRolesForUser(specialUN)); rp.RemoveUsersFromRoles(new[] { specialUN }, new[] { roleName }); Assert.IsFalse(rp.IsUserInRole(specialUN, roleName)); rp.DeleteRole(roleName, false); }
public List <string> GetRolesForUser(string userName) { if (String.IsNullOrEmpty(userName)) { throw new ArgumentException("Value cannot be null or empty.", "userName"); } return(_provider.GetRolesForUser(userName).ToList()); }
public bool IsRepositoryAdministrator(Guid userId, Guid repositoryId) { bool result = false; result |= Repository.GetRepository(repositoryId).Administrators.Any(x => x.Id == userId); result |= RoleProvider.GetRolesForUser(userId).Contains(Definitions.Roles.Administrator); return(result); }
public bool IsRepositoryAdministrator(string username, string repositoryName) { bool result = false; result |= Repository.GetRepository(repositoryName).Administrators.Contains(username, StringComparer.OrdinalIgnoreCase); result |= RoleProvider.GetRolesForUser(username).Contains(Definitions.Roles.Administrator); return(result); }
public string GetRole(string username) { var roles = _provider.GetRolesForUser(username); if (roles != null && roles.Count() > 0) { return(roles[0]); } return(null); }
public bool HasPermission(string username, string repositoryName) { bool result = false; RepositoryModel repositoryModel = Repository.GetRepository(repositoryName); result |= repositoryModel.Users.Contains(username, StringComparer.OrdinalIgnoreCase); result |= repositoryModel.Administrators.Contains(username, StringComparer.OrdinalIgnoreCase); result |= RoleProvider.GetRolesForUser(username).Contains(Definitions.Roles.Administrator); result |= TeamRepository.GetTeams(username).Any(x => repositoryModel.Teams.Contains(x.Name, StringComparer.OrdinalIgnoreCase)); return(result); }
public static bool HasAccess(this IPublicAccessService publicAccessService, string path, MembershipUser member, RoleProvider roleProvider) { var entry = publicAccessService.GetEntryForContent(path.EnsureEndsWith(path)); if (entry == null) { return(true); } var roles = roleProvider.GetRolesForUser(member.UserName); return(entry.Rules.Any(x => x.RuleType == Constants.Conventions.PublicAccess.MemberRoleRuleType && roles.Contains(x.RuleValue))); }
public bool HasPermission(Guid userId, Guid repositoryId) { bool result = false; RepositoryModel repositoryModel = Repository.GetRepository(repositoryId); UserModel user = MemberShipService.GetUserModel(userId); result |= repositoryModel.Users.Any(x => x.Id == userId); result |= repositoryModel.Administrators.Any(x => x.Id == userId); result |= RoleProvider.GetRolesForUser(user.Id).Contains(Definitions.Roles.Administrator); result |= TeamRepository.GetTeams(userId).Any(x => repositoryModel.Teams.Select(y => y.Name).Contains(x.Name, StringComparer.OrdinalIgnoreCase)); return(result); }
public IList <RegisterModel> GetUserRole(string username) { var roles = roleProvider.GetRolesForUser(username); IList <RegisterModel> registerModels = new List <RegisterModel>(); foreach (var r in roles) { var registerModel = new RegisterModel { UserName = username, RoleModelName = r }; registerModels.Add(registerModel); } return(registerModels); }
public void Can_Get_Roles_For_User() { var user = new User { Username = "******", Password = "******" }; MembershipProvider.CreateAccount(user); RoleProvider.CreateRole("admin"); RoleProvider.CreateRole("sales"); RoleProvider.CreateRole("engineering"); RoleProvider.AddUsersToRoles(new[] { "sallen" }, new[] { "admin", "engineering" }); Assert.True(RoleProvider.GetRolesForUser("sallen").Length == 2); }
public string[] GetRolesForCurrentUser() { try { ApplicationServiceHelper.EnsureRoleServiceEnabled(); EnsureProviderEnabled(); IPrincipal user = ApplicationServiceHelper.GetCurrentUser(HttpContext.Current); string username = ApplicationServiceHelper.GetUserName(user); RoleProvider provider = GetRoleProvider(user); return(provider.GetRolesForUser(username)); } catch (Exception e) { LogException(e); throw; } }
public override string[] GetRolesForUser(string username) { LogDebug("Entering CachedProvider.GetRolesForUser"); string[] roles; if (_cache.ContainsKey(username)) { roles = ((List <string>)_cache[username]).ToArray(); return(roles); } roles = _provider.GetRolesForUser(username); if (roles != null && roles.Length > 0) { _cache[username] = new List <string>(roles); } return(roles); }
public override string[] GetRolesForUser(string username) { List <string> userRoles = new List <string>(); foreach (string providerName in m_ProviderList) { RoleProvider rp = Roles.Providers[providerName]; string[] roles = rp.GetRolesForUser(username); foreach (string role in roles) { if (!userRoles.Contains(role)) { userRoles.Add(role); } } } return(userRoles.ToArray()); }
public override void OnActionExecuting(ActionExecutingContext filterContext) { var controller = (filterContext.Controller as LeonniApplicationController); if (controller != null) { if (filterContext.HttpContext != null && filterContext.HttpContext.User != null && filterContext.HttpContext.User.Identity != null) { if (filterContext.HttpContext.User.Identity.IsAuthenticated) { MembershipUser objUser = Membership.GetUser(filterContext.HttpContext.User.Identity.Name); RoleProvider objRoleProvider = Roles.Providers["DefaultRoleProvider"]; var repo = DependencyResolver.Current.GetService <IUserProfileRepository>(); controller.CurrentUser = new LoginModel(); if (objUser != null) { controller.CurrentUser.UserId = (Guid)objUser.ProviderUserKey; controller.CurrentUser.UserName = objUser.UserName; var objUserProfile = repo.GetSingle(x => x.UserId == (Guid)objUser.ProviderUserKey); if (objUserProfile != null) { controller.IsLeonniTeam = repo.GetSingle(x => x.UserId == (Guid)objUser.ProviderUserKey).IsLeonniTeam; } else { controller.IsLeonniTeam = false; } //objRoleProvider. controller.CurrentRole = objRoleProvider.GetRolesForUser(filterContext.HttpContext.User.Identity.Name)[0]; } } } } else { throw new Exception("Always derive controller from LeonniApplicationController"); } base.OnActionExecuting(filterContext); }
private UserDetailModelList GetDetailUsers() { var users = MembershipService.GetAllUsers(); var model = new UserDetailModelList(); model.IsReadOnly = MembershipService.IsReadOnly(); foreach (var user in users) { model.Add(new UserDetailModel { Username = user.Name, Name = user.GivenName, Surname = user.Surname, Email = user.Email, Roles = RoleProvider.GetRolesForUser(user.Name), IsReadOnly = model.IsReadOnly }); } return(model); }
public ActionResult Detail(Guid id) { UserModel user = MembershipService.GetUserModel(id); if (user != null) { var model = new UserDetailModel { Id = user.Id, Username = user.Username, Name = user.GivenName, Surname = user.Surname, Email = user.Email, Roles = RoleProvider.GetRolesForUser(user.Id), IsReadOnly = MembershipService.IsReadOnly() }; return(View(model)); } return(View()); }
public ActionResult Detail(string id) { if (!String.IsNullOrEmpty(id)) { UserModel user = MembershipService.GetUser(id); if (user != null) { var model = new UserDetailModel { Username = user.Name, Name = user.GivenName, Surname = user.Surname, Email = user.Email, Roles = RoleProvider.GetRolesForUser(user.Name), IsReadOnly = MembershipService.IsReadOnly() }; return(View(model)); } } return(View()); }
private IDictionary <string, bool> HasAccess(IEnumerable <string> paths, RoleProvider roleProvider) { // ensure we only lookup user roles once string[] userRoles = null; string[] getUserRoles(string username) { if (userRoles != null) { return(userRoles); } userRoles = roleProvider.GetRolesForUser(username).ToArray(); return(userRoles); } var result = new Dictionary <string, bool>(); foreach (var path in paths) { result[path] = IsLoggedIn() && _publicAccessService.HasAccess(path, CurrentUserName, getUserRoles); } return(result); }
/// <summary> /// Returns true or false if the currently logged in member is authorized based on the parameters provided /// </summary> /// <param name="allowTypes"></param> /// <param name="allowGroups"></param> /// <param name="allowMembers"></param> /// <returns></returns> public virtual bool IsMemberAuthorized( IEnumerable <string> allowTypes = null, IEnumerable <string> allowGroups = null, IEnumerable <int> allowMembers = null) { if (allowTypes == null) { allowTypes = Enumerable.Empty <string>(); } if (allowGroups == null) { allowGroups = Enumerable.Empty <string>(); } if (allowMembers == null) { allowMembers = Enumerable.Empty <int>(); } // Allow by default var allowAction = true; if (IsLoggedIn() == false) { // If not logged on, not allowed allowAction = false; } else { var provider = _membershipProvider; string username; if (provider.IsUmbracoMembershipProvider()) { var member = GetCurrentPersistedMember(); // If a member could not be resolved from the provider, we are clearly not authorized and can break right here if (member == null) { return(false); } username = member.Username; // If types defined, check member is of one of those types var allowTypesList = allowTypes as IList <string> ?? allowTypes.ToList(); if (allowTypesList.Any(allowType => allowType != string.Empty)) { // Allow only if member's type is in list allowAction = allowTypesList.Select(x => x.ToLowerInvariant()).Contains(member.ContentType.Alias.ToLowerInvariant()); } // If specific members defined, check member is of one of those if (allowAction && allowMembers.Any()) { // Allow only if member's Id is in the list allowAction = allowMembers.Contains(member.Id); } } else { var member = provider.GetCurrentUser(); // If a member could not be resolved from the provider, we are clearly not authorized and can break right here if (member == null) { return(false); } username = member.UserName; } // If groups defined, check member is of one of those groups var allowGroupsList = allowGroups as IList <string> ?? allowGroups.ToList(); if (allowAction && allowGroupsList.Any(allowGroup => allowGroup != string.Empty)) { // Allow only if member is assigned to a group in the list var groups = _roleProvider.GetRolesForUser(username); allowAction = allowGroupsList.Select(s => s.ToLowerInvariant()).Intersect(groups.Select(myGroup => myGroup.ToLowerInvariant())).Any(); } } return(allowAction); }
/// <summary> /// Finds the roles by user. /// </summary> /// <param name="user">The user.</param> /// <returns></returns> public IEnumerable <string> FindByUser(MembershipUser user) { return(_roleProvider.GetRolesForUser(user.UserName)); }
public bool MemberIsAdministrator(string username) { return(!string.IsNullOrEmpty(username) && _roleProvider.GetRolesForUser(username).Any(x => x.ToUpperInvariant() == Groups.Administrators.ToUpperInvariant())); }
public List <string> GetRolesForUser(string username) { return(_provider.GetRolesForUser(username).ToList <string>()); }
public string[] GetRolesForUser() { return(roleProvider.GetRolesForUser(null)); }