root/http/thread_feed.cc

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

    Copyright © 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 "article_entry.hh"
#include "error_resource.hh"
#include "feed_resource.hh"
#include "request.hh"
#include "resource_exception.hh"

#include "../config.hh"
#include "../db/db.hh"
#include "../db/threaded.hh"
#include "../msg/entity.hh"
#include "../msg/lexutils.hh"
#include "../uri.hh"

#include <list>
#include <string>

namespace http
{
        class thread_feed : public feed_resource
        {
                db::thread_node::const_ptr art;
                std::list<feed_resource::entry::const_ptr> entries;
                boost::posix_time::ptime latest;
                void add_msg(db::thread_node::const_ptr, db::user::const_ptr);
        public:
                thread_feed(server::conn_cb cb, std::string path);
        protected:
                void prehook(boost::shared_ptr<request> req);
                std::string get_id_uri() const;
                std::string get_alt_uri() const;
                std::string get_title() const;
                boost::posix_time::ptime get_updated() const;
                const std::list<entry::const_ptr> &get_entries() const;
        };

        void thread_feed::prehook(boost::shared_ptr<request> req)
        {
                db::user::const_ptr u = req->get_user();
                db::msg::const_ptr m = art->get_article();
                if (m && !m->reading_authz(u))
                {
                        boost::shared_ptr<resource> er
                                (new error_resource(cb, "403 Forbidden"));
                        throw resource_exception(er);                        
                }
                add_msg(art, u);
                if (entries.empty()) latest = boost::posix_time::second_clock::
                                              universal_time();
        }

        void thread_feed::add_msg(db::thread_node::const_ptr m,
                                  db::user::const_ptr u)
        {
                db::msg::const_ptr art = m->get_article();
                if (art && art->reading_authz(u)) {
                        article_entry::ptr e(new article_entry(m, u));
                        entries.push_front(e);
                        boost::posix_time::ptime date =
                                art->get_entity()->parsed_date();
                        if (latest < date) latest = date;
                }
                const std::list<db::thread_node::ptr> &ch = m->get_children();
                for (std::list<db::thread_node::ptr>::const_iterator it = 
                             ch.begin();
                     it != ch.end(); it++)
                {
                        add_msg(*it, u);
                }
       }

        thread_feed::thread_feed(server::conn_cb cb, std::string path) 
                        : feed_resource(cb)
                        , latest(boost::posix_time::neg_infin)
        {
                try
                {
                        if (path.substr(0,13) != "/feed/thread/")
                                throw db::no_such_article();

                        const db::threaded &thr = cb.dbase().get_threaded();

                        art = thr.lookup_msgid(uri::percent_decode
                                               (path.substr(13)));
                        if (!art) throw db::no_such_article();
                }
                catch (db::no_such_article)
                {
                        boost::shared_ptr<resource> er
                                (new error_resource(cb, "404 No such article"));
                        throw resource_exception(er);
                }
        }

        std::string thread_feed::get_id_uri() const
        {
                std::ostringstream ss;
                // FIXME: use a tag: uri
                ss << "https://"
                   << uri::percent_encode
                        (config["canonical-name"].as<std::string>())
                   << ":"
                   << uri::percent_encode
                        (config["https-port"].as<std::string>())
                   << "/feed/thread/"
                   << uri::percent_encode(art->get_msgid());
                return ss.str();
        }

        std::string thread_feed::get_alt_uri() const
        {
                std::ostringstream ss;
                ss << "https://"
                   << uri::percent_encode
                        (config["canonical-name"].as<std::string>())
                   << ":"
                   << uri::percent_encode
                        (config["https-port"].as<std::string>())
                   << "/thread/"
                   << uri::percent_encode(art->get_msgid());
                return ss.str();
        }

        std::string thread_feed::get_title() const
        {
                db::msg::const_ptr m = art->get_article();
                if (art) {
                        return std::string("Thread about ") + 
                                msg::decode_unstructured
                                (m->get_entity()->get_field("Subject", false));
                } else {
                        return "untitled thread";
                }
        }
        boost::posix_time::ptime thread_feed::get_updated() const
        {
                return latest;
        }
        const std::list<feed_resource::entry::const_ptr> &
        thread_feed::get_entries() const
        {
                return entries;
        }

};

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