Mediator_Class.h

Go to the documentation of this file.

 
 
#pragma once
#ifndef __MEDIATOR_CLASS_H__
#define __MEDIATOR_CLASS_H__
 
#include <exception>
 
#include "helpers/argumentinvalid_error.h"
#include "helpers/formatstring.h"
 
#include "Mediator_User_Classes.h"
#include "Mediator_Group_Classes.h"
 
namespace DesignPatternExamples_cpp
{
 
    class UserGroupsContainer
    {
    public:
        UserList Users;
        GroupList Groups;
    };
 
 
    //########################################################################
    //########################################################################
 
 
    class UserGroupMediator
    {
    private:
        // Normally this would be held somewhere else but for this example,
        // the mediator will be the owner.
        UserGroupsContainer _userGroupsContainer;
 
    public:
        void AddUser(std::string name)
        {
            _userGroupsContainer.Users.AddUser(name);
        }
 
 
        void RemoveUser(std::string name)
        {
            RemoveUserFromAllGroups(name);
            _userGroupsContainer.Users.RemoveUser(name);
        }
 
 
        void AddGroup(std::string name)
        {
            _userGroupsContainer.Groups.AddGroup(name);
        }
 
 
        void RemoveGroup(std::string name)
        {
            _userGroupsContainer.Groups.RemoveGroup(name);
        }
 
 
        void AddUserToGroup(std::string userName, std::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).
            if (_userGroupsContainer.Users.FindUser(userName) == nullptr)
            {
                std::string message = Helpers::formatstring("User '%s' does not exist.  Cannot add to group '%s'!",
                    userName.c_str(), groupName.c_str());
                throw Helpers::argumentinvalid_error("userName", message.c_str());
            }
 
            Group* foundGroup = _userGroupsContainer.Groups.FindGroup(groupName);
            if (foundGroup == nullptr)
            {
                std::string message = Helpers::formatstring("Cannot add user '%s' to group '%s' as that group does not exist!",
                    userName.c_str(), groupName.c_str());
                throw Helpers::argumentinvalid_error("groupName", message.c_str());
            }
 
            foundGroup->AddUser(userName);
        }
 
 
        void RemoveUserFromGroup(std::string userName, std::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).
            if (_userGroupsContainer.Users.FindUser(userName) == nullptr)
            {
                std::string message = Helpers::formatstring("User '%s' does not exist.  Cannot remove from group '%s'!",
                    userName.c_str(), groupName.c_str());
                throw Helpers::argumentinvalid_error("userName", message.c_str());
            }
 
            Group* foundGroup = _userGroupsContainer.Groups.FindGroup(groupName);
            if (foundGroup == nullptr)
            {
                std::string message = Helpers::formatstring("Cannot remove user '%s' from group '%s' as that group does not exist!",
                    userName.c_str(), groupName.c_str());
                throw Helpers::argumentinvalid_error("groupName", message.c_str());
            }
 
            foundGroup->RemoveUser(userName);
        }
 
 
        void RemoveUserFromAllGroups(std::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).
            if (_userGroupsContainer.Users.FindUser(userName) == nullptr)
            {
                std::string message = Helpers::formatstring("User '%s' does not exist.  Cannot remove from all groups'!",
                    userName.c_str());
                throw Helpers::argumentinvalid_error("userName", message.c_str());
            }
 
            for(std::string groupName : _userGroupsContainer.Groups.GroupNames())
            {
                Group* group = _userGroupsContainer.Groups.FindGroup(groupName);
                if (group != nullptr)
                {
                    if (group->ContainsUser(userName))
                    {
                        group->RemoveUser(userName);
                    }
                }
            }
        }
 
 
        bool IsUserInGroup(std::string userName, std::string groupName)
        {
            bool userInGroup = false;
 
            if (_userGroupsContainer.Users.FindUser(userName) == nullptr)
            {
                std::string message = Helpers::formatstring("User '%s' does not exist.  Cannot determine if user is in group '%s'!",
                    userName.c_str(), groupName.c_str());
                throw Helpers::argumentinvalid_error("userName", message.c_str());
            }
 
            Group* foundGroup = _userGroupsContainer.Groups.FindGroup(groupName);
            if (foundGroup == nullptr)
            {
                std::string message = Helpers::formatstring("Cannot determine if user '%s' is in group '%s' as that group does not exist!",
                    userName.c_str(), groupName.c_str());
                throw Helpers::argumentinvalid_error("groupName", message.c_str());
            }
 
            userInGroup = foundGroup->ContainsUser(userName);
 
            return userInGroup;
        }
 
 
        StringList GetGroupsWithUser(std::string userName)
        {
            if (_userGroupsContainer.Users.FindUser(userName) == nullptr)
            {
                std::string message = Helpers::formatstring("User '%s' does not exist.  Cannot get groups containing user!",
                    userName.c_str());
                throw Helpers::argumentinvalid_error("userName", message.c_str());
            }
 
            StringList groupNames;
            for(std::string groupName : _userGroupsContainer.Groups.GroupNames())
            {
                Group* group = _userGroupsContainer.Groups.FindGroup(groupName);
                if (group != nullptr)
                {
                    if (group->ContainsUser(userName))
                    {
                        groupNames.push_back(groupName);
                    }
                }
            }
            return groupNames;
        }
 
 
        StringList GetUsersInGroup(std::string groupName)
        {
            Group* foundGroup = _userGroupsContainer.Groups.FindGroup(groupName);
            if (foundGroup == nullptr)
            {
                std::string message = Helpers::formatstring("Cannot determine get users in group '%s' as that group does not exist!",
                    groupName.c_str());
                throw Helpers::argumentinvalid_error("groupName", message.c_str());
            }
            return foundGroup->Users();
        }
 
 
        StringList GetAllGroups()
        {
            return _userGroupsContainer.Groups.GroupNames();
        }
 
 
        StringList GetAllUsers()
        {
            return _userGroupsContainer.Users.UserNames();
        }
    };
 
} // end namespace
 
#endif // __MEDIATOR_CLASS_H__