Changeset 7eb42bed950e3f81ef9f0d39432e07c55f12cc22

Timestamp:

08/24/10 21:54:44 (21 months ago)

Author:

Antti-Juhani Kaijanaho <antti-juhani@…>

Children:

7ccc366e52cc1e51e123b39fccaf56267361ca58

Parents:

751fac6b567d675afee10e627efb5cf786ce5c83

git-committer:

Antti-Juhani Kaijanaho <antti-juhani@…> (08/24/10 21:54:44)

Message:

[http::markread] Separate the AJAX interface from the regular POST service

Protocol for AJAX mark-read:

• URL is /markread/ajax
• msgid is required
• format=txt is recommended for future compatibility
• if mark action desired, POST without the undo field
• if unmark action desired, POST with undo=yes
• if just want to query, GET
• responses are:
  • AJAX YES if the message is now marked read
  • AJAX NO if the message is now not marked read
  • AJAX ERR followed by error code indicates and error:
    • AJAX ERR NOAUTH if connection is not authenticated
    • AJAX ERR NOMSG if the message is not in the database
• responses are always terminated by CRLF (\r\n)
• for future compatibility, ignore anything after the first line in the response

Of course, HTTP errors occur when they occur.

Signed-off-by: Antti-Juhani Kaijanaho <antti-juhani@…>

Files:

• http/markread.cc (modified) (4 diffs)

http/markread.cc

@@ -23 +23 @@
 #include "resource.hh"
 #include "request.hh"
+#include "../db/db.hh"
 
 namespace http
@@ -29 +30 @@
         {
                 server::conn_cb cb;
-        public:
+                class noauth {};        public:
                 markread(server::conn_cb cb)
                         : cb(cb)
                         {}
+
+                bool action(boost::shared_ptr<request> req);
 
                 boost::shared_ptr<response> operator()
@@ -38 +41 @@
         };
 
+        bool markread::action(boost::shared_ptr<request> req)
+        {
+                enum { QUERY, MARK, UNMARK } action;
+                action = req->get_method() == "POST"
+                        ? (req->get_form_field("undo") != "yes"
+                           ? MARK
+                           : UNMARK)
+                        : QUERY;
+
+                db::user::ptr u = req->get_user();
+                if (!u) throw noauth();
+
+                std::string msgid = req->get_form_field("msgid");
+
+                cb.dbase().lookup_msgid(msgid);
+
+                switch (action)
+                {
+                case QUERY:
+                        break;
+                case MARK:
+                        u->mark_read(msgid);
+                        break;
+                case UNMARK:
+                        u->unmark_read(msgid);
+                        break;
+                }
+                return u->has_read(msgid);
+        }
+
         boost::shared_ptr<response> markread::operator()
         (boost::shared_ptr<request> req, response::factory rf)
         {
-                db::user::ptr u = req->get_user();
-
-                if (!u)
+                if (req->get_path() == "/markread")
                 {
-                        boost::shared_ptr<resource> r
-                                (new reauthn_resource(cb));
-                        throw resource_exception(r);
-                }
-
-                std::string ajax = req->get_form_field("ajax");
-                bool value = req->get_form_field("undo") != "yes";
-                std::string msgid = req->get_form_field("msgid");
-                ::uri redir = req->get_form_field("redir");
-                redir.replace_query_param("markread","no");
-
-                if (req->get_method() == "POST")
-                {
-                        if (value)
-                                u->mark_read(msgid);
-                        else
-                                u->unmark_read(msgid);
-                }
-                if (ajax.empty() || ajax == "no")
-                {
+                        try
+                        {
+                                action(req);
+                        }
+                        catch (noauth)
+                        {
+                                boost::shared_ptr<resource> r
+                                        (new reauthn_resource(cb));
+                                throw resource_exception(r);
+                        }
+                        catch (db::no_such_article)
+                        {
+                                ;
+                        }
+                        ::uri redir = req->get_form_field("redir");
+                        redir.replace_query_param("markread","no");
                         boost::shared_ptr<redir_resource> r
                                 (new redir_resource(cb, redir.to_string(),
                                                     "303 See other"));
                         throw resource_exception(r);
-                }
-                boost::shared_ptr<response> rv = rf("200 Ok");
-                std::ostream &os = rv->body("text/plain");
-                os << "AJAX "
-                   << (u->has_read(msgid) ? "YES" : "NO")
-                   << "\r\n";
-                return rv;
+                }
+                if (req->get_path() == "/markread/ajax")
+                {
+                        std::string res;
+                        try
+                        {
+                                res = action(req) ? "YES" : "NO";
+                        }
+                        catch (noauth)
+                        {
+                                res = "ERR NOAUTH";
+                        }
+                        catch (db::no_such_article)
+                        {
+                                res = "ERR NOMSG";
+                        }
+                        boost::shared_ptr<response> rv = rf("200 Ok");
+                        std::ostream &os = rv->body("text/plain");
+                        os << "AJAX " << res << "\r\n";
+                        return rv;
+                }
+                else
+                {
+                        boost::shared_ptr<error_resource> r
+                                (new error_resource(cb, "404 Not found"));
+                        throw resource_exception(r);
+                }
         }
 }
+
 namespace
 {
@@ -85 +133 @@
                 factory() {
                         server::register_http_resource("/markread", this);
+                        server::register_http_resource("/markread/ajax", this);
                 }
                 boost::shared_ptr<http::resource> operator()