root/http/group_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 "../msg/entity.hh"
#include "../uri.hh"

#include <list>
#include <string>

namespace http
{
        class group_feed : public feed_resource
        {
                db::group::const_ptr gr;
                db::user::const_ptr u;
                std::list<entry::const_ptr> entries;
                boost::posix_time::ptime latest;
        public:
                group_feed(server::conn_cb cb, std::string path);
        protected:
                void prehook(boost::shared_ptr<request>);
                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 group_feed::prehook(boost::shared_ptr<request> req)
        {
                u = req->get_user();
                if (!gr->reading_authz(u)) {
                        boost::shared_ptr<resource> er
                                (new error_resource(cb, "403 Forbidden"));
                        throw resource_exception(er);                        
                }
        }

        group_feed::group_feed(server::conn_cb cb, std::string path) 
                        : feed_resource(cb)
                        , latest(boost::posix_time::neg_infin)
        {
                try
                {
                        gr = cb.dbase().lookup_group(uri::percent_decode
                                                     (path.substr(9)));
                }
                catch (db::no_such_group)
                {
                        boost::shared_ptr<resource> er
                                (new error_resource(cb, "404 No such group"));
                        throw resource_exception(er);
                }

                for (db::group::number i = gr->high_mark();
                     i >= gr->low_mark(); i--)
                {
                        if (entries.size() > 20) break;
                        if (!gr->is_article(i)) continue;
                        db::msg::const_ptr art = gr->get_article(i);
                        db::thread_node::const_ptr tn =
                                cb.dbase().get_threaded().lookup_msgid
                                (art->msgid());
                        article_entry::ptr ae(new article_entry(tn,u));
                        entries.push_back(ae);
                        boost::posix_time::ptime date =
                                art->get_entity()->parsed_date();
                        if (latest < date) latest = date;
                }
                if (entries.empty()) latest = boost::posix_time::second_clock::
                                              universal_time();
        }

        std::string group_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/gr/"
                   << uri::percent_encode(gr->name());
                return ss.str();
        }

        std::string group_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>())
                   << "/gr/"
                   << uri::percent_encode(gr->name());
                return ss.str();
        }

        std::string group_feed::get_title() const
        {
                return gr->name() + " at " + 
                        config["canonical-name"].as<std::string>();
        }
        boost::posix_time::ptime group_feed::get_updated() const
        {
                return latest;
        }
        const std::list<feed_resource::entry::const_ptr> &
        group_feed::get_entries() const
        {
                return entries;
        }

};

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