root/http/sub.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 "authn.hh"
#include "compose.hh"
#include "error_resource.hh"
#include "reauthn_resource.hh"
#include "redir_resource.hh"
#include "request.hh"
#include "resource.hh"
#include "session.hh"

#include "../config.hh"
#include "../db/db.hh"
#include "../db/group.hh"
#include "../db/user.hh"
#include "../logger/logline.hh"

namespace http
{
        class sub : public resource
        {
                server::conn_cb cb;
        public:
                sub(server::conn_cb cb) 
                        : cb(cb)
                        {}
        protected:
                boost::shared_ptr<response> operator()
                (boost::shared_ptr<request>, response::factory);
        };

        boost::shared_ptr<response> sub::operator()
        (boost::shared_ptr<request> req, response::factory)
        {
                std::string redir = req->get_form_field("redir");
                if (redir.empty())
                {
                        redir = "https://" +
                                config["canonical-name"].as<std::string>() +
                                (config["https-port"].as<std::string>() == "443"
                                 ? ""
                                 : ":" +config["https-port"].as<std::string>())+
                                "/";
                }
                boost::shared_ptr<resource> resp(new redir_resource
                                                 (cb, redir, "303 See other"));
                bool sub;
                if (req->get_path() == "/sub")
                {
                        sub = true;
                }
                else if (req->get_path() == "/unsub")
                {
                        sub = false;
                }
                else
                {
                        resp.reset(new error_resource(cb, "404 Not found"));
                        throw resource_exception(resp);
                }
                db::group::ptr gr;
                try
                {
                        gr = cb.dbase().lookup_group(req->get_form_field("group"));
                }
                catch (db::no_such_group)
                {
                        logger::logline ll;
                        ll << "no such group " << req->get_form_field("group");
                        throw resource_exception(resp);
                }
                if (!req->is_authenticated())
                {
                        logger::logline ll;
                        ll << "not logged in ";
                        throw resource_exception(resp);
                }
                if (req->get_method() != "POST") throw resource_exception(resp);
                db::user::ptr u = req->get_user();
                if (!u) throw resource_exception(resp);
                if (sub)
                {
                        gr->add_subscriber(u, cb, req->get_peer());
                }
                else
                {
                        gr->delete_subscriber(u, cb);
                }
                throw resource_exception(resp);
       }
}

namespace
{
        class factory : public server::http_resource_factory
        {
        public:
                factory() {
                        server::register_http_resource("/sub", this);
                        server::register_http_resource("/unsub", this);
                }
                boost::shared_ptr<http::resource> operator()
                (server::conn_cb cb,std::string) {
                        boost::shared_ptr<http::resource> rv
                                (new http::sub(cb));
                        return rv;
                }
        };
        factory f;
}