Implement listing of crate invitations

Connects to rust-lang#959.

Author: carols10cents

src/crate_owner_invitation.rs

@@ -0,0 +1,82 @@
+use conduit::{Request, Response};
+use diesel::prelude::*;
+use time::Timespec;
+
+use db::RequestTransaction;
+use schema::{crate_owner_invitations, users, crates};
+use user::RequestUser;
+use util::errors::CargoResult;
+use util::RequestUtils;
+
+/// The model representing a row in the `crate_owner_invitations` database table.
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Identifiable, Queryable)]
+#[primary_key(invited_user_id, crate_id)]
+pub struct CrateOwnerInvitation {
+    pub invited_user_id: i32,
+    pub invited_by_user_id: i32,
+    pub crate_id: i32,
+    pub created_at: Timespec,
+}
+
+#[derive(Insertable, Clone, Copy, Debug)]
+#[table_name = "crate_owner_invitations"]
+pub struct NewCrateOwnerInvitation {
+    pub invited_user_id: i32,
+    pub invited_by_user_id: i32,
+    pub crate_id: i32,
+}
+
+impl CrateOwnerInvitation {
+    pub fn invited_by_username(&self, conn: &PgConnection) -> String {
+        users::table
+            .find(self.invited_by_user_id)
+            .select(users::gh_login)
+            .first(&*conn)
+            .unwrap_or_else(|_| String::from("(unknown username)"))
+    }
+
+    pub fn crate_name(&self, conn: &PgConnection) -> String {
+        crates::table
+            .find(self.crate_id)
+            .select(crates::name)
+            .first(&*conn)
+            .unwrap_or_else(|_| String::from("(unknown crate name)"))
+    }
+
+    pub fn encodable(self, conn: &PgConnection) -> EncodableCrateOwnerInvitation {
+        EncodableCrateOwnerInvitation {
+            invited_by_username: self.invited_by_username(conn),
+            crate_name: self.crate_name(conn),
+            crate_id: self.crate_id,
+            created_at: ::encode_time(self.created_at),
+        }
+    }
+}
+
+/// The serialization format for the `CrateOwnerInvitation` model.
+#[derive(Deserialize, Serialize, Debug)]
+pub struct EncodableCrateOwnerInvitation {
+    pub invited_by_username: String,
+    pub crate_name: String,
+    pub crate_id: i32,
+    pub created_at: String,
+}
+
+/// Handles the `GET /me/crate_owner_invitations` route.
+pub fn list(req: &mut Request) -> CargoResult<Response> {
+    let conn = &*req.db_conn()?;
+    let user_id = req.user()?.id;
+
+    let invitations = crate_owner_invitations::table
+        .filter(crate_owner_invitations::invited_user_id.eq(user_id))
+        .load::<CrateOwnerInvitation>(&*conn)?
+        .into_iter()
+        .map(|i| i.encodable(conn))
+        .collect();
+
+    #[derive(Serialize)]
+    struct R {
+        invitations: Vec<EncodableCrateOwnerInvitation>,
+    }
+    Ok(req.json(&R { invitations }))
+}

src/lib.rs

@@ -76,6 +76,7 @@ pub mod badge;
 pub mod categories;
 pub mod category;
 pub mod config;
+pub mod crate_owner_invitation;
 pub mod db;
 pub mod dependency;
 pub mod dist;
@@ -183,6 +184,10 @@ pub fn middleware(app: Arc<App>) -> MiddlewareBuilder {
     api_router.get("/me/tokens", C(token::list));
     api_router.post("/me/tokens", C(token::new));
     api_router.delete("/me/tokens/:id", C(token::revoke));
+    api_router.get(
+        "/me/crate_owner_invitations",
+        C(crate_owner_invitation::list),
+    );
     api_router.get("/summary", C(krate::summary));
     let api_router = Arc::new(R404(api_router));
 

src/tests/owners.rs

@@ -2,8 +2,13 @@ use {CrateList, GoodCrate};
 
 use cargo_registry::owner::EncodableOwner;
 use cargo_registry::user::EncodablePublicUser;
+use cargo_registry::crate_owner_invitation::{EncodableCrateOwnerInvitation,
+                                             NewCrateOwnerInvitation};
+use cargo_registry::schema::crate_owner_invitations;
 
 use conduit::{Handler, Method};
+use diesel;
+use diesel::prelude::*;
 
 #[derive(Deserialize)]
 struct TeamResponse {
@@ -291,3 +296,74 @@ fn check_ownership_one_crate() {
     assert_eq!(json.users[0].kind, "user");
     assert_eq!(json.users[0].name, user.name);
 }
+
+#[test]
+fn invitations_are_empty_by_default() {
+    #[derive(Deserialize)]
+    struct R {
+        invitations: Vec<EncodableCrateOwnerInvitation>,
+    }
+
+    let (_b, app, middle) = ::app();
+    let mut req = ::req(
+        app.clone(),
+        Method::Get,
+        "/api/v1/me/crate_owner_invitations",
+    );
+
+    let user = {
+        let conn = app.diesel_database.get().unwrap();
+        ::new_user("user_no_invites")
+            .create_or_update(&conn)
+            .unwrap()
+    };
+    ::sign_in_as(&mut req, &user);
+
+    let mut response = ok_resp!(middle.call(&mut req));
+    let json: R = ::json(&mut response);
+
+    assert_eq!(json.invitations.len(), 0);
+}
+
+#[test]
+fn invitations_list() {
+    #[derive(Deserialize)]
+    struct R {
+        invitations: Vec<EncodableCrateOwnerInvitation>,
+    }
+
+    let (_b, app, middle) = ::app();
+    let mut req = ::req(
+        app.clone(),
+        Method::Get,
+        "/api/v1/me/crate_owner_invitations",
+    );
+    let (krate, user) = {
+        let conn = app.diesel_database.get().unwrap();
+        let owner = ::new_user("inviting_user").create_or_update(&conn).unwrap();
+        let user = ::new_user("invited_user").create_or_update(&conn).unwrap();
+        let krate = ::CrateBuilder::new("invited_crate", owner.id).expect_build(&conn);
+
+        // This should be replaced by an actual call to the route that `owner --add` hits once
+        // that route creates an invitation.
+        let invitation = NewCrateOwnerInvitation {
+            invited_by_user_id: owner.id,
+            invited_user_id: user.id,
+            crate_id: krate.id,
+        };
+        diesel::insert(&invitation)
+            .into(crate_owner_invitations::table)
+            .execute(&*conn)
+            .unwrap();
+        (krate, user)
+    };
+    ::sign_in_as(&mut req, &user);
+
+    let mut response = ok_resp!(middle.call(&mut req));
+    let json: R = ::json(&mut response);
+
+    assert_eq!(json.invitations.len(), 1);
+    assert_eq!(json.invitations[0].invited_by_username, "inviting_user");
+    assert_eq!(json.invitations[0].crate_name, "invited_crate");
+    assert_eq!(json.invitations[0].crate_id, krate.id);
+}