root/http/threads.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/threaded.hh"
#include "../html/util.hh"
#include "../server.hh"
#include "../tlate/empty_value.hh"
#include "../tlate/group_value.hh"
#include "../tlate/list_value.hh"
#include "../tlate/msg_value.hh"
#include "../tlate/tlate.hh"
#include "../uri.hh"

#include <boost/shared_ptr.hpp>

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

        void threads::set_attributes(boost::shared_ptr<request> req,
                                     tlate::data_model::ptr am)
        {
                boost::shared_ptr<db::user> u = req->get_user();                

                boost::shared_ptr<db::group> gr;
                try
                {
                        gr = cb.dbase().lookup_group
                                (uri::percent_decode
                                 (req->get_path().substr(4)));
                }
                catch (db::no_such_group)
                {
                        boost::shared_ptr<resource> er
                                (new error_resource(cb, "404 No such group"));
                        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);
                        
                }

                bool only_summary = req->get_form_field("summary") == "true";

                am->insert("group", new tlate::group_value(gr, u));

                if (only_summary)
                        am->insert("thread_summary", new tlate::empty_value);

                if (gr->posting_authz(u))
                        am->insert("posting-uri", compose::get_posting_uri(gr));

                if (!gr->reading_authz(u))
                {
                        am->insert("restricted", new tlate::empty_value);
                }
                else
                {
                        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::list_value::ptr tl(new tlate::list_value);
                        std::list<db::thread_node::ptr> thrs 
                                = cb.dbase().get_threaded().get_threads(gr);

                        thrs.sort(db::thread_node::cmp_latest_date_rev);

                        size_t cur = 0;
                        size_t total = 0;
                        for (std::list<db::thread_node::ptr>::const_iterator
                                     it = thrs.begin();
                             it != thrs.end(); it++)
                        {
                                total++;
                                if (cur >= start + length) continue;
                                cur++;
                                if (cur > start)
                                        tl->push_back
                                                (tlate::msg_value::mk(*it, u));
                        }
                        am->insert("threads", tl);

                        tlate::data_model::ptr pg(new tlate::data_model);
                        pg->insert("first", start + 1);
                        pg->insert("last", cur);
                        pg->insert("size", cur - start);
                        pg->insert("max_size", length);
                        pg->insert("total", total);
                        if (cur < total)
                        {
                                ::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);
                }
        }

};

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