root/db/group.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 "group.hh"
#include "role.hh"
#include "user.hh"

#include "../config.hh"
#include "../msg/entity.hh"
#include "../msg/multipart.hh"
#include "../msg/lexutils.hh"
#include "../msg/text_plain.hh"
#include "../smtp_client/smtp_client.hh"
#include "../tlate/data_model.hh"
#include "../tlate/group_value.hh"
#include "../tlate/user_value.hh"
#include "../tlate/tlate.hh"

#include "../assert.hh"

namespace db
{
        group::group(std::string name,
                     boost::shared_ptr<db> dbase,
                     boost::posix_time::ptime stamp,
                     bool reading_restricted, std::string descr)
                : the_name(name), stamp(stamp),
                  descr(descr),
                  dbase(dbase),
                  count(0), displacement(1)
        {
                if (!reading_restricted) readers.insert(role::anon());
                readers.insert(role::authn());
                posters.insert(role::poster());
        }


        group::number group::file(boost::shared_ptr<msg::msg> m,
                                  server::conn_cb cb)
        {
                msgs.push_back(m);
                number rv = displacement + msgs.size() - 1;
                m->xref(shared_from_this(), rv);
                count++;

                ensure_subscriber_role();
                const std::set<boost::shared_ptr<user> > &us =
                        subscriber_role->get_users();
                std::list<std::string> recv;
                for (std::set<boost::shared_ptr<user> >::const_iterator it =
                             us.begin();
                     it != us.end(); it++)
                {
                        user::ptr u = *it;
                        if (!u->is_delivery_email_verified()) continue;
                        recv.push_back(u->get_delivery_email());
                }

                if (recv.empty()) return rv;

                ::msg::multipart::ptr nm =
                          m->get_entity()->clone_as_multipart();
                {
                        std::string subject = nm->get_field("subject", false);
                        util::strip_crlf(subject);
                        std::string tag = "["; tag += the_name; tag += "]";
                        if (subject.find(tag) == std::string::npos)
                                nm->replace_field("Subject",
                                                  tag + " " + subject);
                }
                nm->replace_field("To",
                                  name() + "@" +
                                  config["canonical-name"].as<std::string>());
                nm->replace_field("List-Id",
                                  "<" + 
                                  name() + "." +
                                  config["canonical-name"].as<std::string>() +
                                  ">");

                tlate::data_model::ptr mam(new tlate::data_model);
                mam->insert("group", new tlate::group_value(shared_from_this(),
                                                            user::ptr()));

                boost::shared_ptr<tlate::tlate> tl =
                        tlate::tlate::parse("sub_footer.txt");
                std::ostringstream mos;
                mos << tl->eval(mam);
                ::msg::text_plain::ptr sub(new ::msg::text_plain
                                           (mos.str(),
                                            ::msg::content_type(DEFAULT_CT)));
                nm->append_part(sub);
                                  
                cb.smtpc().send_mail(recv, nm->get_entity());

                return rv;
        }

        void group::file(boost::shared_ptr<msg::msg> m, number n)
        {
                assert(n >= displacement);
                if (msgs.empty()) displacement = n;
                size_t n_ = n - displacement;
                if (n_ >= msgs.size()) msgs.resize(n_+1);
                msgs[n_] = m;
                m->xref(shared_from_this(), n);
                count++;
        }

        bool group::authz(boost::shared_ptr<const user> u,
                          const std::set<role::ptr> & rs)
        {
                if (!u) return rs.find(role::anon()) != rs.end();
                const std::set<role::ptr> & urs = u->get_roles();
                for (std::set<role::ptr>::const_iterator it
                             = urs.begin();
                     it != urs.end(); it++)
                {
                        if (rs.find(*it) != rs.end()) return true;
                }
                return false;
        }
        void group::ensure_subscriber_role()
        {
                if (subscriber_role) return;

                std::string subrn = role::get_subscriber_role(the_name);
                subscriber_role = dbase->lookup_role(subrn);
                if (!subscriber_role)
                {
                        subscriber_role = dbase->create_role(subrn, "");
                }
        }

        void group::send_submail(user::const_ptr u, const char *tln,
                                 server::conn_cb cb)
        {
                std::string ton = u->get_display_name();
                std::string to = u->get_delivery_email();
                std::string from = 
                        config["alue-name"].as<std::string>() +
                        " <" +
                        config["operator-email"].as<std::string>() +
                        ">";

                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(u));
                mam->insert("group",
                            new tlate::group_value(shared_from_this(), u));

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

        void group::add_subscriber(boost::shared_ptr<user> u,
                                   server::conn_cb cb,
                                   boost::asio::ip::address peer)
        {
                BOOST_ASSERT(u);
                ensure_subscriber_role();
                u->add_role(subscriber_role);
                if (!u->is_delivery_email_verified())
                        u->send_delivery_email_cookie
                                (cb, peer.to_string());
                else
                        send_submail(u, "sub.msg", cb);
        }
        void group::delete_subscriber(boost::shared_ptr<user> u,
                                      server::conn_cb cb)
        {
                ensure_subscriber_role();
                u->delete_role(subscriber_role);
                if (u->is_delivery_email_verified())
                        send_submail(u, "unsub.msg", cb);
        }
        bool group::is_subscriber(boost::shared_ptr<const user> u)
        {
                if (!u) return false;
                ensure_subscriber_role();
                const std::set<boost::shared_ptr<role> > &rs = u->get_roles();
                return rs.find(subscriber_role) != rs.end();
        }
}