public bool IsUserInNestedGroup(Group group, User user) { foreach (var member in group.GroupMembers.Where(x => x.IsGroup())) { var nestedGroup = this.groupRepository.GroupNamed(member.TenantId, member.Name); if (nestedGroup != null) { var isInNestedGroup = nestedGroup.IsMember(user, this); if (isInNestedGroup) return true; } } return false; }
public bool ConfirmUser(Group group, User user) { bool userConfirmed = true; User confirmedUser = this.UserRepository .UserWithUsername(group.TenantId, user.Username); if (confirmedUser == null || !confirmedUser.Enabled) { userConfirmed = false; } return userConfirmed; }
public bool IsUserInRole(User user, string roleName) { AssertionConcern.AssertArgumentNotNull(user, "User must not be null."); AssertionConcern.AssertArgumentNotEmpty(roleName, "Role name must not be null."); var authorized = false; if (user.Enabled) { var role = this.roleRepository.RoleNamed(user.TenantId, roleName); if (role != null) { authorized = role.IsInRole(user, new GroupMemberService(this.userRepository, this.groupRepository)); } } return authorized; }
public void AssignUser(User user) { AssertionConcern.AssertArgumentNotNull(user, "User must not be null."); AssertionConcern.AssertArgumentEquals(this.TenantId, user.TenantId, "Wrong tenant for this user."); this.Group.AddUser(user); DomainEventPublisher .Instance .Publish(new UserAssignedToRole( this.TenantId, this.Name, user.Username, user.Person.Name.FirstName, user.Person.Name.LastName, user.Person.EmailAddress.Address)); }
public void AddUser(User user) { AssertionConcern.AssertArgumentNotNull(user, "User must not be null."); AssertionConcern.AssertArgumentEquals(this.TenantId, user.TenantId, "Wrong tenant for this group."); AssertionConcern.AssertArgumentTrue(user.Enabled, "User is not enabled."); if (this.GroupMembers.Add(user.ToGroupMember()) && !this.IsInternalGroup()) { DomainEventPublisher .Instance .Publish(new GroupUserAdded( this.TenantId, this.Name, user.Username)); } }
public void RemoveUser(User user) { AssertionConcern.AssertArgumentNotNull(user, "User must not be null."); AssertionConcern.AssertArgumentEquals(this.TenantId, user.TenantId, "Wrong tenant for this group."); // not a nested remove, only direct member if (this.GroupMembers.Remove(user.ToGroupMember()) && !this.IsInternalGroup()) { DomainEventPublisher .Instance .Publish(new GroupUserRemoved( this.TenantId, this.Name, user.Username)); } }
public bool IsMember(User user, GroupMemberService groupMemberService) { AssertionConcern.AssertArgumentNotNull(user, "User must not be null."); AssertionConcern.AssertArgumentEquals(this.TenantId, user.TenantId, "Wrong tenant for this group."); AssertionConcern.AssertArgumentTrue(user.Enabled, "User is not enabled."); var isMember = this.GroupMembers.Contains(user.ToGroupMember()); if (isMember) { isMember = groupMemberService.ConfirmUser(this, user); } else { isMember = groupMemberService.IsUserInNestedGroup(this, user); } return isMember; }
/// <summary> /// Uses a <see cref="GroupMemberService"/> to determine /// whether a given <see cref="User"/> has this role, including /// by way of nested <see cref="Group"/> membership. /// </summary> /// <param name="user"> /// A <see cref="User"/> entity to check. /// </param> /// <param name="groupMemberService"> /// The instance of <see cref="GroupMemberService"/> /// relayed to the <see cref="Group.IsMember"/> method. /// </param> /// <returns> /// <c>true</c> if the given <paramref name="user"/> /// has this role; otherwise, <c>false</c>. /// </returns> public bool IsInRole(User user, GroupMemberService groupMemberService) { return this.internalGroup.IsMember(user, groupMemberService); }
public void UnassignUser(User user) { AssertionConcern.AssertArgumentNotNull(user, "User must not be null."); AssertionConcern.AssertArgumentEquals(this.TenantId, user.TenantId, "Wrong tenant for this user."); this.internalGroup.RemoveUser(user); DomainEventPublisher .Instance .Publish(new UserUnassignedFromRole( this.TenantId, this.Name, user.Username)); }
/// <summary> /// Determines whether a <see cref="User"/>'s declared /// membership in a <see cref="Group"/> is valid. /// </summary> /// <param name="group"> /// An instance of <see cref="Group"/> which may have /// the <paramref name="user"/> as a member. /// </param> /// <param name="user"> /// An instance of <see cref="User"/> which may be /// a member of the <paramref name="group"/>. /// </param> /// <returns> /// <c>true</c> if the <paramref name="user"/>'s /// <see cref="User.TenantId"/> matches that of /// the <paramref name="group"/> and the user's /// <see cref="User.IsEnabled"/> property is true; /// otherwise, <c>false</c>. /// </returns> public bool ConfirmUser(Group group, User user) { User confirmedUser = this.userRepository.UserWithUsername(group.TenantId, user.Username); return ((confirmedUser == null) || (!confirmedUser.IsEnabled)); }
public bool IsUserInNestedGroup(Group group, User user) { bool isInNestedGroup = false; foreach (GroupMember member in group.GroupMembers) { if (member.IsGroup()) { Group nestedGroup = this.GroupRepository .GroupNamed(member.TenantId, member.Name); if (nestedGroup != null) { isInNestedGroup = nestedGroup.IsMember(user, this); } } if (isInNestedGroup) { break; } } return isInNestedGroup; }
public User RegisterUser( string invitationIdentifier, string username, string password, Enablement enablement, Person person) { AssertionConcern.AssertStateTrue(this.Active, "Tenant is not active."); User user = null; if (this.IsRegistrationAvailableThrough(invitationIdentifier)) { // ensure same tenant person.TenantId = this.TenantId; user = new User(this.TenantId, username, password, enablement, person); } return user; }
public bool ConfirmUser(Group group, User user) { var confirmedUser = this.userRepository.UserWithUsername(group.TenantId, user.Username); var userConfirmed = confirmedUser == null || !confirmedUser.Enabled; return userConfirmed; }