root/http/article.cc

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

    Copyright © 2009, 2010 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 "request.hh"
#include "templated_resource.hh"

#include "../db/db.hh"
#include "../db/msg.hh"
#include "../db/threaded.hh"
#include "../html/util.hh"
#include "../msg/content_type.hh"
#include "../msg/lexutils.hh"
#include "../msg/text_plain.hh"
#include "../server.hh"
#include "../tlate/msg_value.hh"
#include "../tlate/thread_value.hh"
#include "../tlate/tlate.hh"
#include "../uri.hh"
#include "../util.hh"

#include <boost/shared_ptr.hpp>

namespace http
{
        class article : public templated_resource
        {
        protected:
                void set_attributes(boost::shared_ptr<request>,
                                    tlate::data_model::ptr);
        public:
                article(server::conn_cb cb) 
                        : templated_resource(cb, "article.html")
                        {}
        };

        void article::set_attributes(boost::shared_ptr<request> req,
                                     tlate::data_model::ptr am)
        {
                boost::shared_ptr<db::msg> art;
                bool is_single;
                try
                {
                        size_t inx;
                        if (req->get_path().substr(0,4) == "/id/")
                        {
                                inx = 4;
                                is_single = true;
                        }
                        else if (req->get_path().substr(0,8) == "/thread/")
                        {
                                inx = 8;
                                is_single = false;
                        }
                        else
                                throw db::no_such_article();

                        art = cb.dbase().lookup_msgid
                                (uri::percent_decode
                                 (req->get_path().substr(inx)));
                }
                catch (db::no_such_article)
                {
                        boost::shared_ptr<resource> er
                                (new error_resource(cb, "404 No such article"));
                        throw resource_exception(er);
                }
                catch (uri::invalid e)
                {
                        std::string msg = "400 ";
                        msg += e.what();
                        boost::shared_ptr<resource> er
                                (new error_resource(cb, msg));
                        throw resource_exception(er);
                        
                }

                boost::shared_ptr<db::user> u = req->get_user();

                if (is_single && u && req->get_form_field("markread") != "no")
                        u->mark_read(art->msgid());
                
                db::thread_node::ptr tn = 
                        cb.dbase().get_threaded().lookup_msgid(art->msgid());
                am->insert("article", tlate::msg_value::mk(tn, u));
                if (!is_single) 
                {
                        std::string f = req->get_form_field("s");
                        size_t start = util::is_number(f)
                                ? util::parse_nonnegative_integer<size_t>(f)
                                : 0;
                        f = req->get_form_field("n");
                        size_t length = util::is_number(f)
                                ? util::parse_nonnegative_integer<size_t>(f)
                                : 10;

                        tlate::thread_value::ptr tv
                                (new tlate::thread_value(tn, u));
                        size_t tvl = tv->size();
                        tv->slice_window(start, length);
                        am->insert("thread", tv);

                        tlate::data_model::ptr pg(new tlate::data_model);
                        pg->insert("first", start + 1);
                        pg->insert("last", start + tv->size());
                        pg->insert("size", tv->size());
                        pg->insert("max_size", length);
                        pg->insert("total", tvl);

                        if (start + length < tvl)
                        {
                                ::uri u = req->get_uri();
                                u.replace_query_param("s", start + length);
                                u.replace_query_param("n", length);
                                pg->insert("next", u.to_string());
                        }
                        
                        if (start > 0)
                        {
                                ::uri u = req->get_uri();
                                u.replace_query_param("s",
                                                      start > length
                                                      ? start - length
                                                      : 0);
                                u.replace_query_param("n", length);
                                pg->insert("prev", u.to_string());
                        }
                        am->insert("page", pg);
                }

                ::uri fhon_uri = req->get_uri();
                fhon_uri.replace_query_param("fullhdr", "true");
                am->insert("fullhdr-on", html::quote(fhon_uri.to_string(),
                                                         false));

                ::uri fhoff_uri = req->get_uri();
                fhoff_uri.replace_query_param("fullhdr", "false");
                am->insert("fullhdr-off",
                            html::quote(fhoff_uri.to_string(), false));

                if (req->get_uri().get_query_param("fullhdr") == "true")
                        am->insert("full-header", "");
        }

};

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