root/http/moderate.cc

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

    Copyright © 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 "error_resource.hh"
#include "reauthn_resource.hh"
#include "redir_resource.hh"
#include "resource.hh"
#include "request.hh"
#include "../db/db.hh"
#include "../db/msg.hh"

namespace http
{
        class moderate : public resource
        {
                server::conn_cb cb;
                class noauth {};
        public:
                moderate(server::conn_cb cb)
                        : cb(cb)
                        {}

                void action(boost::shared_ptr<request> req);

                boost::shared_ptr<response> operator()
                (boost::shared_ptr<request> req, response::factory);
        };

        void moderate::action(boost::shared_ptr<request> req)
        {
                db::user::ptr u = req->get_user();
                if (!u) throw noauth();

                std::string action = req->get_form_field("action");
                std::string msgid = req->get_form_field("msgid");
                std::string reason = req->get_form_field("reason");

                size_t re = reason.find_first_of("\r\n");
                if (re != std::string::npos) reason = reason.substr(0, re);

                db::msg::ptr m = cb.dbase().lookup_msgid(msgid);

                if (!u->is_moderator(m))
                {
                        boost::shared_ptr<error_resource> r
                                (new error_resource(cb, "403 Not a moderator"));
                        throw resource_exception(r);
                }

                if (action != "KILL" && action != "SPAM" && action != "CLEAR")
                        return;

                cb.dbase().add_record("MODERATION " + u->get_userid() + "\n" +
                                      action + " " + m->msgid() + " " + reason);
        }

        boost::shared_ptr<response> moderate::operator()
        (boost::shared_ptr<request> req, response::factory)
        {
                if (req->get_path() == "/mod")
                {
                        try
                        {
                                if (req->get_method() == "POST") action(req);
                        }
                        catch (noauth)
                        {
                                boost::shared_ptr<resource> r
                                        (new reauthn_resource(cb));
                                throw resource_exception(r);
                        }
                        catch (db::no_such_article)
                        {
                                ;
                        }
                        ::uri redir = req->get_form_field("redir");
                        boost::shared_ptr<redir_resource> r
                                (new redir_resource(cb, redir.to_string(),
                                                    "303 See other"));
                        throw resource_exception(r);
                }
                else
                {
                        boost::shared_ptr<error_resource> r
                                (new error_resource(cb, "404 Not found"));
                        throw resource_exception(r);
                }
        }
}

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