root/http/smanage.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/user.hh"
#include "../html/util.hh"
#include "../logger/logline.hh"
#include "../msg/lexutils.hh"
#include "../server.hh"
#include "../tlate/tlate.hh"
#include "../util.hh"

#include <boost/shared_ptr.hpp>

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

                void reload_action(boost::shared_ptr<request>,
                                   tlate::data_model::ptr,
                                   std::string error_message = "");

                void post_action(boost::shared_ptr<request> req,
                                 tlate::data_model::ptr);
        };

        void smanage::reload_action(boost::shared_ptr<request> req,
                                    tlate::data_model::ptr am,
                                    std::string error_message)
        {
                if (!error_message.empty())
                        am->insert("error", html::quote(error_message, false));
                am->insert("diname", req->get_form_field("diname"));
                am->insert("diaddr", req->get_form_field("diaddr"));
                std::string deaddr = req->get_form_field("deaddr");
                am->insert("deaddr", deaddr);
                db::user::ptr u = req->get_session()->get_user();

                if (u->is_delivery_email_verified())
                        am->insert("verified");
                else if (deaddr == u->get_delivery_email() && deaddr != "")
                        am->insert("verify");

                if (req->has_form_field("allow_clear"))
                        am->insert("allow_clear",
                                   req->get_form_field("allow_clear"));
        }

        void smanage::post_action(boost::shared_ptr<request> req,
                                  tlate::data_model::ptr am)
        {
                std::string (*const pd)(std::string) = uri::percent_decode;

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

                u->set_display_name(pd(req->get_form_field("diname")));
                u->set_display_email(pd(req->get_form_field("diaddr")));
                if (u->set_delivery_email(pd(req->get_form_field("deaddr")))) {
                        u->send_delivery_email_cookie
                                (cb, req->get_peer().to_string());
                }
                u->set_allow_cleartext_password
                        (req->has_form_field("allow_clear"));
                reload_action(req, am, "Saved.");
        }

        void smanage::set_attributes(boost::shared_ptr<request> req,
                                     tlate::data_model::ptr am)
        {
                std::string (*const q)(std::string,bool) = html::quote;

                boost::shared_ptr<resource> resp;
                if (req->get_path() != "/editme")
                {
                        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("change_button"))
                {
                        if (req->get_method() == "POST")
                                post_action(req, am);
                        else
                                reload_action(req, am);
                        
                }
                else if (req->has_form_field("verify_button"))
                {
                        boost::shared_ptr<db::user> u =
                                req->get_session()->get_user();
                        if (req->get_method() == "POST")
                        {
                                u->send_delivery_email_cookie
                                        (cb, req->get_peer().to_string());
                                reload_action(req, am,
                                              "Verification email has been "
                                              "sent to " +
                                              u->get_delivery_email());
                        }
                        else
                                reload_action(req, am);
                }
                else
                {
                        boost::shared_ptr<db::user> u = 
                                req->get_session()->get_user();
                        am->insert("diname", q(u->get_display_name(),false));
                        am->insert("diaddr", q(u->get_display_email(),false));
                        am->insert("deaddr", q(u->get_delivery_email(),false));
                        if (u->is_delivery_email_verified())
                                am->insert("verified");
                        else if (u->get_delivery_email() != "")
                                am->insert("verify");
                                           
                        if (u->allow_cleartext_password())
                                am->insert("allow_clear",
                                           req->get_form_field("allow_clear"));
                }

                boost::shared_ptr<db::user> usr= req->get_session()->get_user();
                am->insert("userid", q(usr->get_userid(), false));
                am->insert("action", "/editme");
                am->insert("method", "post");
                am->insert("enctype", "application/x-www-form-urlencoded");
                am->insert("accept_charlist", "utf8");
       }
}

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