root/db/user.cc

/*  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/>.

 */

#include "db.hh"
#include "user.hh"
#include "role.hh"

#include "../config.hh"
#include "../msg/lexutils.hh"
#include "../smtp_client/smtp_client.hh"
#include "../tlate/data_model.hh"
#include "../tlate/tlate.hh"
#include "../tlate/user_value.hh"
#include "../uri.hh"

#include <sstream>

namespace
{
        std::string mktoken()
        {
                std::string token;
                boost::random_device rand;
                for (size_t i = 0; i < 30; i++)
                        token += util::b64_char(rand() % 64);
                token += "99"; /* just in case the last char
                                  is punctuation, in order to
                                  not confuse users */
                return token;
        }
}

namespace db
{
        user::user(std::string userid,
                   boost::shared_ptr<db> dbase,
                   boost::shared_ptr<password_handler> pwh)
                : userid(userid)
                , do_allow_cleartext_password(false)
                , delivery_email_verified(false)
                , dbase(dbase)
                , pwh(pwh)
        {
                roles.insert(role::authn());
        }

        void user::set_display_name(std::string new_name)
        {
                if (new_name == display_name) return;
                std::ostringstream os;
                os << "USER "
                   << userid 
                   << "\ndisplay_name "
                   << new_name
                   << "\n";
                dbase->add_record(os.str());
                BOOST_ASSERT(display_name == new_name);
        }
        void user::set_display_email(std::string new_addr)
        {
                if (new_addr == display_email) return;
                std::ostringstream os;
                os << "USER "
                   << userid 
                   << "\ndisplay_email "
                   << new_addr
                   << "\n";
                dbase->add_record(os.str());
                BOOST_ASSERT(display_email == new_addr);
        }
        bool user::set_delivery_email(std::string new_addr)
        {
                if (new_addr == delivery_email) return false;
                std::string token = mktoken();
                std::ostringstream os;
                os << "USER "
                   << userid 
                   << "\ndelivery_email "
                   << new_addr
                   << "\ndelivery_email_verified no"
                   << "\ndelivery_email_cookie "
                   << token
                   << "\n";
                dbase->add_record(os.str());
                BOOST_ASSERT(delivery_email == new_addr);
                BOOST_ASSERT(!delivery_email_verified);
                BOOST_ASSERT(delivery_email_cookie == token);
                return true;
        }
        void user::set_allow_cleartext_password(bool val)
        {
                if (val == do_allow_cleartext_password) return;
                std::ostringstream os;
                os << "USER "
                   << userid 
                   << "\nallow_cleartext_password "
                   << (val ? "yes" : "no")
                   << "\n";
                dbase->add_record(os.str());
                BOOST_ASSERT(do_allow_cleartext_password == val);
        }
        void user::send_delivery_email_cookie(server::conn_cb cb,
                                              std::string request_ip)
        {
                if (delivery_email_cookie == "")
                {
                        std::string token = mktoken();
                        std::ostringstream os;
                        os << "USER "
                           << userid 
                           << "\ndelivery_email_cookie "
                           << token
                           << "\n";
                        dbase->add_record(os.str());
                        BOOST_ASSERT(delivery_email_cookie == token);
                }
                std::string ton = display_name;
                std::string to = delivery_email;
                std::string from = 
                        config["alue-name"].as<std::string>() +
                        " <" +
                        config["operator-email"].as<std::string>() +
                        ">";

                std::ostringstream link;
                link << "https://"
                     << config["canonical-name"].as<std::string>()
                     << (config["https-port"].as<std::string>() == "443"
                         ? ""
                         : ":" + config["https-port"].as<std::string>())
                     << "/confirm/"
                     << uri::percent_encode(delivery_email_cookie);

                tlate::data_model::ptr mam(new tlate::data_model);

                mam->insert("from", from);
                mam->insert("to",
                            ::msg::make_phrase(ton) + " <" + to + ">");
                mam->insert("user", new tlate::user_value(shared_from_this()));
                mam->insert("link", link.str());
                mam->insert("request_ip", request_ip);
                
                boost::shared_ptr<tlate::tlate> tl =
                        tlate::tlate::parse("confirm.msg");
                std::ostringstream mos;
                mos << tl->eval(mam);
                        
                std::list<std::string> recv;
                recv.push_back(to);
                                
                cb.smtpc().send_mail(recv, mos.str());
        }
        bool user::verify_delivery_email(std::string cookie, server::conn_cb cb)
        {
                if (delivery_email_verified) return true;
                if (cookie == "") return false;
                if (delivery_email_cookie != cookie) return false;
                std::ostringstream os;
                os << "USER "
                   << userid 
                   << "\ndelivery_email_verified yes"
                   << "\n";
                dbase->add_record(os.str());
                BOOST_ASSERT(delivery_email_verified);

                tlate::data_model::ptr mam(new tlate::data_model);

                std::string ton = display_name;
                std::string to = delivery_email;
                std::string from = 
                        config["alue-name"].as<std::string>() +
                        " <" +
                        config["operator-email"].as<std::string>() +
                        ">";
                mam->insert("from", from);
                mam->insert("to",
                            ::msg::make_phrase(ton) + " <" + to + ">");
                mam->insert("user", new tlate::user_value(shared_from_this()));

                boost::shared_ptr<tlate::tlate> tl =
                        tlate::tlate::parse("confirmed.msg");
                std::ostringstream mos;
                mos << tl->eval(mam);
                        
                std::list<std::string> recv;
                recv.push_back(to);
                                
                cb.smtpc().send_mail(recv, mos.str());

                return true;
        }

        void user::add_role(boost::shared_ptr<role> r)
        {
                if (roles.find(r) != roles.end()) return;

                std::ostringstream os;
                os << "ROLE "
                   << r->get_name()
                   << "\r\n"
                   << "USER ADD " + userid;
                dbase->add_record(os.str());
                BOOST_ASSERT(roles.find(r) != roles.end());
                BOOST_ASSERT(r->users.find(shared_from_this())!=r->users.end());
        }

        void user::delete_role(boost::shared_ptr<role> r)
        {
                if (roles.find(r) == roles.end()) return;
                std::ostringstream os;
                os << "ROLE "
                   << r->get_name()
                   << "\r\n"
                   << "USER DEL " + userid;
                dbase->add_record(os.str());
                BOOST_ASSERT(roles.find(r) == roles.end());
                BOOST_ASSERT(r->users.find(shared_from_this())==r->users.end());
        }

        void user::mark_read(std::string msgid)
        {
                if (has_read(msgid)) return;
                std::ostringstream os;
                os << "USER " << userid << "\r\n"
                   << "has_read " << msgid;
                dbase->add_record(os.str());
                BOOST_ASSERT(has_read(msgid));
        }
        void user::unmark_read(std::string msgid)
        {
                if (!has_read(msgid)) return;
                std::ostringstream os;
                os << "USER " << userid << "\r\n"
                   << "has_not_read " << msgid;
                dbase->add_record(os.str());
                BOOST_ASSERT(!has_read(msgid));
        }

        bool user::is_group_moderator(std::string grn) const
        {
                for (std::set<role::ptr>::const_iterator it = roles.begin();
                     it != roles.end(); it++)
                {
                        role::ptr r = *it;
                        if (r->is_moderator_for(grn)) return true;
                }
                return false;
        }

        bool user::is_moderator(boost::shared_ptr<const group> gr) const
        {
                return is_group_moderator(gr->name());
        }

        bool user::is_moderator(boost::shared_ptr<const msg> m) const
        {
                std::list<std::string> ngs = m->get_newsgroups();
                for (std::list<std::string>::const_iterator it = ngs.begin();
                     it != ngs.end(); it++)
                {
                        if (is_group_moderator(*it)) return true;
                }
                return false;
        }

}