root/db/role.hh

/*  This file is part of Alue, the multiprotocol Internet discussion daemon

    Copyright © 2009, 2010, 2011 Antti-Juhani Kaijanaho

    Alue is free software: you can redistribute it and/or modify it
    under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    Alue is distributed in the hope that it will be useful, but
    WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with Alue.  If not, see <http://www.gnu.org/licenses/>.

 */

#ifndef GUARD_DB_ROLE_HH
#define GUARD_DB_ROLE_HH

#include <boost/noncopyable.hpp>
#include <boost/shared_ptr.hpp>

#include <set>
#include <string>

namespace db
{
        class user;
        class role : private boost::noncopyable
        {
                std::string name;
                std::string description;
                std::set<boost::shared_ptr<user> > users;

                friend class db;
                friend class user;

                static const std::string subscriber_prefix;
                static const std::string moderator_prefix;
        public:
                typedef boost::shared_ptr<role> ptr;
                typedef boost::shared_ptr<const role> const_ptr;

                role(std::string name, std::string descr) 
                        : name(name), description(descr)
                        {}

                std::string get_name() const { return name; }
                std::string get_description() const { return name; }

                bool is_moderator() {
                        return  name.substr(0, moderator_prefix.length())
                                ==
                                moderator_prefix;
                }
                bool is_moderator_for(std::string grn);

                const std::set<boost::shared_ptr<user> > &get_users() const {
                        return users;
                }

                static ptr anon() {
                        static ptr rv;
                        if (!rv) rv.reset(new role("anonymous",
                                                   "Anonymous user"));
                        return rv;
                }
                static ptr authn() {
                        static ptr rv;
                        if (!rv) rv.reset(new role("authenticated",
                                                   "Authenticated user"));
                        return rv;
                }
                static ptr poster() {
                        static ptr rv;
                        if (!rv) rv.reset(new role("poster",
                                                   "Basic poster authorization")
                                );
                        return rv;
                }

                bool is_subscriber_role() const
                        { return is_subscriber_role(name); }

                std::string whose_subscriber_role() const {
                        return name.substr(subscriber_prefix.length());
                }

                static bool is_subscriber_role(std::string str) {
                        return  str.substr(0, subscriber_prefix.length())
                                ==
                                subscriber_prefix;
                }

                static std::string get_subscriber_role(std::string group) {
                        return subscriber_prefix + group;
                }
        };
}

#endif /* GUARD_DB_ROLE_HH */