Poll for updates for a user

Author: alexcrichton

src/lib.rs

@@ -73,6 +73,7 @@ pub fn middleware(app: Arc<App>) -> MiddlewareBuilder {
     router.get("/logout", C(user::logout));
     router.get("/me", C(user::me));
     router.put("/me/reset_token", C(user::reset_token));
+    router.get("/me/updates", C(user::updates));
     router.get("/summary", C(krate::summary));
     router.get("/crates", C(krate::index));
     router.get("/crates/:crate_id", C(krate::show));

src/tests/user.rs

@@ -7,6 +7,7 @@ use conduit_test::MockRequest;
 use cargo_registry::krate::EncodableCrate;
 use cargo_registry::user::{User, EncodableUser};
 use cargo_registry::db::RequestTransaction;
+use cargo_registry::version::EncodableVersion;
 
 #[deriving(Decodable)]
 struct AuthResponse { url: String, state: String }
@@ -106,3 +107,52 @@ fn my_packages() {
     let response: Response = ::json(&mut response);
     assert_eq!(response.crates.len(), 1);
 }
+
+#[test]
+fn following() {
+    #[deriving(Decodable)]
+    struct R {
+        versions: Vec<EncodableVersion>,
+        meta: Meta,
+    }
+    #[deriving(Decodable)] struct Meta { more: bool }
+
+    let (_b, app, middle) = ::app();
+    let mut req = ::req(app, conduit::Get, "/");
+    ::mock_user(&mut req, ::user());
+    ::mock_crate(&mut req, "foo");
+    ::mock_crate(&mut req, "bar");
+
+    let mut response = ok_resp!(middle.call(req.with_path("/me/updates")
+                                               .with_method(conduit::Get)));
+    let r = ::json::<R>(&mut response);
+    assert_eq!(r.versions.len(), 0);
+    assert_eq!(r.meta.more, false);
+
+    ok_resp!(middle.call(req.with_path("/crates/foo/follow")
+                            .with_method(conduit::Put)));
+    ok_resp!(middle.call(req.with_path("/crates/bar/follow")
+                            .with_method(conduit::Put)));
+
+    let mut response = ok_resp!(middle.call(req.with_path("/me/updates")
+                                               .with_method(conduit::Get)));
+    let r = ::json::<R>(&mut response);
+    assert_eq!(r.versions.len(), 2);
+    assert_eq!(r.meta.more, false);
+
+    let mut response = ok_resp!(middle.call(req.with_path("/me/updates")
+                                               .with_method(conduit::Get)
+                                               .with_query("per_page=1")));
+    let r = ::json::<R>(&mut response);
+    assert_eq!(r.versions.len(), 1);
+    assert_eq!(r.meta.more, true);
+
+    ok_resp!(middle.call(req.with_path("/crates/bar/unfollow")
+                            .with_method(conduit::Put)));
+    let mut response = ok_resp!(middle.call(req.with_path("/me/updates")
+                                               .with_method(conduit::Get)
+                                               .with_query("page=2&per_page=1")));
+    let r = ::json::<R>(&mut response);
+    assert_eq!(r.versions.len(), 0);
+    assert_eq!(r.meta.more, false);
+}

src/user/mod.rs

@@ -10,10 +10,12 @@ use oauth2::Authorization;
 use pg::PostgresRow;
 use pg::types::ToSql;
 
+use {Model, Version};
 use app::RequestApp;
 use db::{Connection, RequestTransaction};
-use util::{RequestUtils, CargoResult, internal, Require, ChainError, human};
 use util::errors::NotFound;
+use util::{RequestUtils, CargoResult, internal, Require, ChainError, human};
+use version::EncodableVersion;
 
 pub use self::middleware::{Middleware, RequestUser};
 
@@ -225,3 +227,37 @@ pub fn me(req: &mut Request) -> CargoResult<Response> {
     let token = user.api_token.clone();
     Ok(req.json(&R{ user: user.clone().encodable(), api_token: token }))
 }
+
+pub fn updates(req: &mut Request) -> CargoResult<Response> {
+    let user = try!(req.user());
+    let (offset, limit) = try!(req.pagination(10, 100));
+    let tx = try!(req.tx());
+    let sql = "SELECT versions.*, crates.name AS crate_name
+                 FROM versions
+               INNER JOIN follows
+                  ON follows.user_id = $1 AND
+                     follows.crate_id = versions.crate_id
+               INNER JOIN crates
+                  ON crates.id = versions.crate_id
+               ORDER BY versions.created_at DESC
+               OFFSET $2 LIMIT $3";
+
+    let stmt = try!(tx.prepare(sql));
+    let mut versions = Vec::new();
+    for row in try!(stmt.query(&[&user.id, &offset, &limit])) {
+        let version: Version = Model::from_row(&row);
+        let name: String = row.get("crate_name");
+        versions.push(version.encodable(name.as_slice()));
+    }
+
+    let sql = format!("SELECT 1 WHERE EXISTS({})", sql);
+    let stmt = try!(tx.prepare(sql.as_slice()));
+    let more = try!(stmt.query(&[&user.id, &(offset + limit), &limit]))
+                  .next().is_some();
+
+    #[deriving(Encodable)]
+    struct R { versions: Vec<EncodableVersion>, meta: Meta }
+    #[deriving(Encodable)]
+    struct Meta { more: bool }
+    Ok(req.json(&R{ versions: versions, meta: Meta { more: more } }))
+}