Mediator_Class.cs

Go to the documentation of this file.

 
 
using System;
using System.Collections.Generic;
 
 
namespace DesignPatternExamples_csharp
{
    class UserGroupsContainer
    {
        public UserList Users = new UserList();
        public GroupList Groups = new GroupList();
    }
 
 
    //########################################################################
    //########################################################################
 
 
    public class UserGroupMediator
    {
        // Normally this would be held somewhere else but for this example,
        // the mediator will be the owner.
        UserGroupsContainer _userGroupsContainer = new UserGroupsContainer();
 
 
        public void AddUser(string name)
        {
            _userGroupsContainer.Users.AddUser(name);
        }
 
 
        public void RemoveUser(string name)
        {
            RemoveUserFromAllGroups(name);
            _userGroupsContainer.Users.RemoveUser(name);
        }
 
 
        public void AddGroup(string name)
        {
            _userGroupsContainer.Groups.AddGroup(name);
        }
 
 
        public void RemoveGroup(string name)
        {
            _userGroupsContainer.Groups.RemoveGroup(name);
        }
 
 
        public void AddUserToGroup(string userName, string groupName)
        {
            // As mediator, we must verify the user exists because the group
            // has no way to do this (groups have no knowledge of how users
            // are stored, by design).
            User? foundUser = _userGroupsContainer.Users.FindUser(userName);
            if (foundUser == null)
            {
                string message = String.Format("User '{0}' does not exist.  Cannot add to group '{1}'!", userName, groupName);
                throw new ArgumentException(message);
            }
 
            Group? foundGroup = _userGroupsContainer.Groups.FindGroup(groupName);
            if (foundGroup == null)
            {
                string message = String.Format("Cannot add user '{0}' to group '{1}' as that group does not exist!", userName, groupName);
                throw new ArgumentException(message);
            }
 
            foundGroup.AddUser(userName);
        }
 
 
        public void RemoveUserFromGroup(string userName, string groupName)
        {
            // As mediator, we must verify the user exists because the group
            // has no way to do this (groups have no knowledge of how users
            // are stored, by design).
            User? foundUser = _userGroupsContainer.Users.FindUser(userName);
            if (foundUser == null)
            {
                string message = String.Format("User '{0}' does not exist.  Cannot remove from group '{1}'!", userName, groupName);
                throw new ArgumentException(message);
            }
 
            Group? foundGroup = _userGroupsContainer.Groups.FindGroup(groupName);
            if (foundGroup == null)
            {
                string message = String.Format("Cannot remove user '{0}' from group '{1}' as that group does not exist!", userName, groupName);
                throw new ArgumentException(message);
            }
 
            foundGroup.RemoveUser(userName);
        }
 
 
        public void RemoveUserFromAllGroups(string userName)
        {
            // As mediator, we must verify the user exists because the group
            // has no way to do this (groups have no knowledge of how users
            // are stored, by design).
            User? foundUser = _userGroupsContainer.Users.FindUser(userName);
            if (foundUser == null)
            {
                string message = String.Format("User '{0}' does not exist.  Cannot remove from all groups'!", userName);
                throw new ArgumentException(message);
            }
 
            foreach (string groupName in _userGroupsContainer.Groups.GroupNames)
            {
                Group? group = _userGroupsContainer.Groups.FindGroup(groupName);
                if (group != null)
                {
                    if (group.ContainsUser(userName))
                    {
                        group.RemoveUser(userName);
                    }
                }
            }
        }
 
 
        public bool IsUserInGroup(string userName, string groupName)
        {
            bool userInGroup = false;
 
            User? foundUser = _userGroupsContainer.Users.FindUser(userName);
            if (foundUser == null)
            {
                string message = String.Format("User '{0}' does not exist.  Cannot determine if user is in group '{1}'!", userName, groupName);
                throw new ArgumentException(message);
            }
 
            Group? foundGroup = _userGroupsContainer.Groups.FindGroup(groupName);
            if (foundGroup == null)
            {
                string message = String.Format("Cannot determine if user '{0}' is in group '{1}' as that group does not exist!", userName, groupName);
                throw new ArgumentException(message);
            }
 
            userInGroup = foundGroup.ContainsUser(userName);
 
            return userInGroup;
        }
 
 
        public string[] GetGroupsWithUser(string userName)
        {
            User? foundUser = _userGroupsContainer.Users.FindUser(userName);
            if (foundUser == null)
            {
                string message = String.Format("User '{0}' does not exist.  Cannot get groups container user!", userName);
                throw new ArgumentException(message);
            }
 
            List<string> groupNames = new List<string>();
            foreach(string groupName in _userGroupsContainer.Groups.GroupNames)
            {
                Group? group = _userGroupsContainer.Groups.FindGroup(groupName);
                if (group != null)
                {
                    if (group.ContainsUser(userName))
                    {
                        groupNames.Add(groupName);
                    }
                }
            }
            return groupNames.ToArray();
        }
 
 
        public string[] GetUsersInGroup(string groupName)
        {
            Group? foundGroup = _userGroupsContainer.Groups.FindGroup(groupName);
            if (foundGroup == null)
            {
                string message = String.Format("Cannot determine get users in group '{0}' as that group does not exist!", groupName);
                throw new ArgumentException(message);
            }
            return (string[])foundGroup.Users.Clone();
        }
 
 
        public string[] GetAllGroups()
        {
            return (string[])_userGroupsContainer.Groups.GroupNames.Clone();
        }
 
 
        public string[] GetAllUsers()
        {
            return (string[])_userGroupsContainer.Users.UserNames.Clone();
        }
    }
}