root/db/user.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_USER_HH
#define GUARD_DB_USER_HH

#include "password_handler.hh"
#include "../server.hh"

#include <boost/enable_shared_from_this.hpp>
#include <boost/noncopyable.hpp>
#include <boost/shared_ptr.hpp>
#include <set>
#include <string>

namespace db
{
        class db;
        class group;
        class msg;
        class role;

        class user : public boost::noncopyable
                   , public boost::enable_shared_from_this<user>
        {
                std::string userid;
                std::string display_name;
                std::string display_email;
                std::string delivery_email;
                bool do_allow_cleartext_password;
                bool delivery_email_verified;
                std::string delivery_email_cookie;

                boost::shared_ptr<db> dbase;
                boost::shared_ptr<password_handler> pwh;

                std::set< boost::shared_ptr<role> > roles;

                std::set<std::string> read_msgids;

                bool is_group_moderator(std::string) const;

                friend class db;
        public:
                typedef boost::shared_ptr<user> ptr;
                typedef boost::shared_ptr<const user> const_ptr;

                user(std::string userid,
                     boost::shared_ptr<db> dbase,
                     boost::shared_ptr<password_handler> pwh);
                
                std::string get_userid() const { return userid; }

                std::string get_display_name() const { return display_name; }
                void set_display_name(std::string);

                std::string get_display_email() const { return display_email; }
                void set_display_email(std::string);

                std::string get_delivery_email() const {
                        return delivery_email;
                }
                bool set_delivery_email(std::string);

                bool is_delivery_email_verified() const {
                        return delivery_email_verified;
                }
                void send_delivery_email_cookie(server::conn_cb cb,
                                                std::string request_ip);
                bool verify_delivery_email(std::string cookie,
                                           server::conn_cb cb);

                bool allow_cleartext_password() const {
                        return do_allow_cleartext_password;
                }
                void set_allow_cleartext_password(bool);

                bool verify_password(std::string s) const {
                        return pwh->verify_password(userid, s);
                }
                void set_password(std::string s) {
                        pwh->set_password(userid, s);
                }
                
                const std::set<boost::shared_ptr<role> > &get_roles() const {
                        return roles;
                }

                void add_role(boost::shared_ptr<role> r);

                void delete_role(boost::shared_ptr<role> r);

                bool has_read(std::string msgid) const {
                        return read_msgids.find(msgid) != read_msgids.end();
                }
                void mark_read(std::string msgid);
                void unmark_read(std::string msgid);

                bool is_moderator(boost::shared_ptr<const group> gr) const;
                bool is_moderator(boost::shared_ptr<const msg> m) const;

                static std::string passwd_problems(std::string pw) {
                        std::string err;
                        if (pw.length() < 6) err += "Password is too short. ";
                        if (pw.find_first_of(" \t") != std::string::npos)
                                err += "Password contains a space or a tab. ";
                        return err;
                }

                boost::shared_ptr<db> get_db() const { return dbase; };
        };
}

#endif /* GUARD_DB_USER_HH */