root/http/compose.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 "reauthn_resource.hh"
#include "redir_resource.hh"
#include "request.hh"
#include "templated_resource.hh"
#include "session.hh"

#include "../db/db.hh"
#include "../db/msg.hh"
#include "../db/threaded.hh"
#include "../html/util.hh"
#include "../logger/logline.hh"
#include "../msg/entity.hh"
#include "../msg/lexutils.hh"
#include "../msg/text_plain.hh"
#include "../msg/util.hh"
#include "../server.hh"
#include "../tlate/empty_value.hh"
#include "../tlate/group_value.hh"
#include "../tlate/list_value.hh"
#include "../tlate/missing_value.hh"
#include "../tlate/tlate.hh"

#include <boost/shared_ptr.hpp>

namespace
{
        class listed_group_value : public tlate::group_value
        {
                bool post_to;
                bool followup_to;
        public:
                listed_group_value(boost::shared_ptr<db::group> gr,
                                   boost::shared_ptr<db::user> u,
                                   bool post_to, bool followup_to)
                        : group_value(gr, u)
                        , post_to(post_to)
                        , followup_to(followup_to)
                        {}

                value::const_ptr get(std::string) const;
        };

        tlate::value::const_ptr listed_group_value::get(std::string var) const
        {
                /**/ if (var == "post-to")
                {
                        tlate::value::ptr rv;
                        if (post_to) rv.reset(new tlate::empty_value);
                        return rv;
                }
                else if (var == "followup-to")
                {
                        tlate::value::ptr rv;
                        if (followup_to) rv.reset(new tlate::empty_value);
                        return rv;
                }
                else
                        return group_value::get(var);
        }
}

namespace http
{
        std::string compose::get_posting_uri(db::group::const_ptr gr)
        {
                return std::string("/compose?group=") +
                        uri::percent_encode(gr->name());
        }

        std::string compose::get_followup_uri(db::msg::const_ptr m)
        {
                return std::string("/compose?precursor=") +
                        uri::percent_encode(m->msgid());
        }

        void compose::reload_action(boost::shared_ptr<request> req,
                                    tlate::data_model::ptr am,
                                    std::string error_message)
        {
                typedef request::form_data_iterator cit_type;
                std::pair<cit_type, cit_type> its;

                if (!error_message.empty())
                        am->insert("error", html::quote(error_message, false));
                am->insert("subject", req->get_form_field("subject"));
                am->insert("references", req->get_form_field("references"));
                am->insert("body", req->get_form_field("body"));
                   
                std::list<std::string> ngs;
                its = req->get_form_fields("newsgroups");
                for (cit_type it = its.first; it != its.second; it++)
                        ngs.push_back(it->second);

                std::list<std::string> fus;
                its = req->get_form_fields("followups");
                for (cit_type it = its.first; it != its.second; it++)
                        fus.push_back(it->second);

                return respond_compose(req, am, ngs, fus);
        }

        void compose::post_action(boost::shared_ptr<request> req,
                                  tlate::data_model::ptr am)
        {
                std::ostringstream os;

                typedef std::multimap<std::string,std::string>::const_iterator 
                        cit_type;
                std::pair<cit_type, cit_type> its;

                boost::shared_ptr<db::user> usr= req->get_session()->get_user();
                os << "From: "
                   << msg::make_phrase(usr->get_display_name())
                   << " <"
                   << usr->get_display_email()
                   << ">\r\n";

                os << "Newsgroups: ";
                bool first = true;
                its = req->get_form_fields("newsgroups");
                for (cit_type it = its.first; it != its.second; it++)
                {
                        if (!first) os << ",";
                        first = false;
                        os << it->second;
                }
                os << "\r\n";

                its = req->get_form_fields("followups");
                if (its.first != its.second)
                {
                        os << "Followup-To: ";
                        first = true;
                        for (cit_type it = its.first; it != its.second; it++)
                        {
                                if (!first) os << ",";
                                first = false;
                                os << it->second;
                        }
                        os << "\r\n";
                }

                os << "Subject: "
                   << msg::encode_unstructured(req->get_form_field("subject")) 
                   << "\r\n";

                std::string refs = req->get_form_field("references");
                if (!refs.empty())
                {
                        os << "References: " << refs << "\r\n";

                }


                std::string content_type = 
                        "text/plain; charset=\"utf-8\";"
                        " format=flowed; delsp=yes";

                msg::text_plain tp(msg::crlf_canonize(req->get_form_field("body")),
                                   msg::content_type(content_type));

                std::ostringstream body;
                for (size_t i = 0; i < tp.num_paras(); i++)
                {
                        const msg::text_plain::para &p = tp.get_para(i);
                        const std::string qs(p.quote_depth(), '>');
                        for (size_t j = 0; j < p.num_lines(); j++)
                        {
                                std::string line = p.get_line(j);
                                if (p.quote_depth() == 0 &&
                                    !line.empty() && line[0] == 'F')
                                {
                                        line.insert(0, " ");
                                }
                                size_t ll = 78 - p.quote_depth();
                                while (!line.empty())
                                {
                                        size_t sp = ll;
                                        while (sp > 0 && line[sp] != ' ') sp--;
                                        if (sp == 0)
                                        {
                                                body << qs
                                                     << line.substr(0, ll)
                                                     << " \r\n";
                                                line.erase(0, ll);
                                        }
                                        else
                                        {
                                                body << qs
                                                     << line.substr(0, sp+1)
                                                     << " \r\n";
                                                line.erase(0, sp+1);
                                        }
                                }
                                if (j < p.num_lines()-1) body << qs << " \r\n";
                        }
                        body << qs << "\r\n";
                }
                os << "User-Agent: alue/0 (HTTPS)\r\n"
                   << "Content-Type: " << content_type << "\r\n"
                   << "\r\n"
                   << body.str()
                   << "\r\n";

                db::msg::ptr m;
                try
                {
                        msg::entity::ptr e = msg::entity::mk(os.str(), false);
                        msg::complete_mime(e);
                        m = cb.dbase().file(e, req->get_peer(), usr, cb);
                }
                catch (std::exception &e)
                {
                        return reload_action(req, am, e.what());
                }
                logger::logline ll;
                ll << "httpd for " 
                   << req->get_peer() 
                   << ": POST created " 
                   << m->msgid();
                ll.close();
                boost::shared_ptr<resource> rr
                        (new redir_resource(cb, 
                                            "/id/" + 
                                            uri::percent_encode(m->msgid()),
                                            "303 See other"));
                throw resource_exception(rr);
        }

        void compose::set_attributes(boost::shared_ptr<request> req,
                                     tlate::data_model::ptr am)
        {
                boost::shared_ptr<resource> resp;
                if (req->get_path() != "/compose")
                {
                        resp.reset(new error_resource(cb, "404 Not found"));
                        throw resource_exception(resp);
                }
                if (!req->is_authenticated())
                {
                        resp.reset(new reauthn_resource(cb));
                        throw resource_exception(resp);
                }

                if (req->has_form_field("post_button"))
                {
                        if (req->get_method() == "POST")
                                return post_action(req, am);
                        else
                                return reload_action(req, am);
                }

                if (req->has_form_field("group"))
                {
                        boost::shared_ptr<db::group> group;
                        try
                        {
                                group = cb.dbase().lookup_group
                                        (req->get_form_field("group"));
                        }
                        catch (db::no_such_group)
                        {
                                resp.reset(new error_resource
                                           (cb, "404 No such group " + 
                                            req->get_form_field("group")));
                                throw resource_exception(resp);
                        }
                        return new_thread(req, am, group);
                }

                if (req->has_form_field("precursor"))
                {
                        boost::shared_ptr<db::msg> art;
                        std::string pre = req->get_form_field("precursor");
                        try
                        {
                                art = cb.dbase().lookup_msgid(pre);
                        }
                        catch (db::no_such_article)
                        {
                                resp.reset(new error_resource
                                           (cb, "404 No such article " + pre));
                                throw resource_exception(resp);
                        }
                        return followup(req, am, art);
                }
                // FIXME
                resp.reset(new error_resource(cb, "404 Not found"));
                throw resource_exception(resp);
        }

        void compose::followup(boost::shared_ptr<request> req,
                               tlate::data_model::ptr am,
                               boost::shared_ptr<db::msg> precursor)
        {
                std::string (*const q)(std::string,bool) = html::quote;
                //std::string (*const p)(std::string) = uri::percent_encode;

                std::string subject = 
                        precursor->get_entity()->get_field("Subject", false);
                util::strip_crlf(subject);
                if (subject.substr(0, 4) != "Re: ")
                        subject.insert(0, "Re: ");
                am->insert("subject", subject);

                std::string fups = precursor->get_entity()->get_field
                        ("Followup-To", false);
                util::strip(fups);
                if (fups.empty() || fups == "poster") // FIXME
                {
                        fups = precursor->get_entity()->get_field("Newsgroups", false);
                        util::strip(fups);
                }
                std::list<std::string> ngs = msg::parse_newsgroups_list(fups);


#if 0
                std::string distrib = precursor->get_entity()->get_field
                        ("Distribution", false);
                util::strip_crlf(distrib);
                if (!distrib.empty()) 
                        ss << "Distribution: " << distrib << '\n';
#endif

                std::string refs = precursor->get_entity()->get_field
                        ("References", false);
                util::strip_crlf(refs);
                if (!refs.empty()) refs += ' ';
                refs += precursor->msgid();
#if 0
                bool folded = false;
                for (size_t i = 0; i < refs.length(); i++)
                {
                        switch (refs[i])
                        {
                        case ' ': case '\t': 
                                if (!folded) 
                                {
                                        refs.insert(i, "\r\n");
                                        i += 2;
                                        folded = true;
                                }
                                break;
                        case '\r': case '\n':
                                refs[i] = ' ';
                                folded = true;
                                break;
                        default:
                                folded = false;
                        }
                }
#endif
                am->insert("references", q(refs, false));

                std::ostringstream body;

                std::string from =
                        precursor->get_entity()->get_field("From", false);
                util::strip_crlf(from);
                body << from << " wrote: \n\n";

                msg::text_plain tp(precursor->get_entity());

                for (size_t i = 0; i < tp.num_paras(); i++)
                {
                        const msg::text_plain::para &p = tp.get_para(i);
                        const std::string qs(p.quote_depth()+1, '>');
                        for (size_t j = 0; j < p.num_lines(); j++)
                        {
                                std::string line = p.get_line(j);
                                size_t nsp = line.find_last_not_of(" ");
                                if (nsp == std::string::npos) nsp = 0;
                                if (nsp + 1 < line.length()) line.erase(nsp+1);
                                body << qs
                                     << line
                                     << "\n";
                        }
                }

                am->insert("body", q(body.str(), false));

                return respond_compose(req, am, ngs, ngs);
        }

        void compose::new_thread(boost::shared_ptr<request> req,
                                 tlate::data_model::ptr am,
                                 boost::shared_ptr<db::group> group)
        {
                std::string (*const q)(std::string,bool) = html::quote;
//                std::string (*const p)(std::string) = uri::percent_encode;

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

                am->insert("subject", "");

                std::list<std::string> grs;
                grs.push_back(q(group->name(), false));

                am->insert("references", new tlate::empty_value);
                am->insert("body", "");

                return respond_compose(req, am, grs, grs);
        }

        void compose::respond_compose(boost::shared_ptr<request> req,
                                     tlate::data_model::ptr am,
                                     std::list<std::string> &newsgroups,
                                     std::list<std::string> &followups)
        {
                std::string (*const q)(std::string,bool) = html::quote;
                //std::string (*const p)(std::string) = uri::percent_encode;

                boost::shared_ptr<db::user> usr= req->get_session()->get_user();
                am->insert("from", q(usr->get_display_name() +
                                     " <" +
                                     usr->get_display_email() +
                                     ">",
                                     false));

                am->insert("action", "/compose");
                am->insert("method", "post");
                am->insert("enctype",
                           q("application/x-www-form-urlencoded",
                             false));
                am->insert("accept_charlist", q("utf8",false));

                tlate::list_value::ptr grs(new tlate::list_value);
                for (db::db::group_iterator git = cb.dbase().groups_begin();
                     git != cb.dbase().groups_end(); git++)
                {
                        bool ngsel = std::find(newsgroups.begin(),
                                               newsgroups.end(),
                                               git->second->name())
                                != newsgroups.end();
                        bool fusel = std::find(followups.begin(),
                                               followups.end(),
                                               git->second->name())
                                != followups.end();
                        tlate::group_value::ptr gr
                                (new listed_group_value(git->second, usr,
                                                        ngsel, fusel));
                        grs->push_back(gr);
                }
                am->insert("grouplist", grs);
         }

};

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