Auto merge of #3403 - Turbo87:invitation-users, r=pietroalbini

GET /me/crate_owner_invitations: Add `users` list

This will allow us to display avatars on the frontend for the `inviter` part of the invitations.

Author: bors

src/controllers/crate_owner_invitation.rs

@@ -1,28 +1,82 @@
 use super::frontend_prelude::*;
 
-use crate::models::{CrateOwner, CrateOwnerInvitation, OwnerKind};
-use crate::schema::{crate_owner_invitations, crate_owners};
-use crate::views::{EncodableCrateOwnerInvitation, InvitationResponse};
+use crate::models::{CrateOwner, CrateOwnerInvitation, OwnerKind, User};
+use crate::schema::{crate_owner_invitations, crate_owners, crates, users};
+use crate::views::{EncodableCrateOwnerInvitation, EncodablePublicUser, InvitationResponse};
+use diesel::dsl::any;
+use std::collections::HashMap;
 
 /// Handles the `GET /me/crate_owner_invitations` route.
 pub fn list(req: &mut dyn RequestExt) -> EndpointResult {
-    let user_id = req.authenticate()?.user_id();
-    let conn = &*req.db_read_only()?;
+    // Ensure that the user is authenticated
+    let user = req.authenticate()?.user();
 
+    // Load all pending invitations for the user
+    let conn = &*req.db_read_only()?;
     let crate_owner_invitations: Vec<CrateOwnerInvitation> = crate_owner_invitations::table
-        .filter(crate_owner_invitations::invited_user_id.eq(user_id))
+        .filter(crate_owner_invitations::invited_user_id.eq(user.id))
         .load(&*conn)?;
+
+    // Make a list of all related users
+    let user_ids: Vec<_> = crate_owner_invitations
+        .iter()
+        .map(|invitation| invitation.invited_by_user_id)
+        .collect();
+
+    // Load all related users
+    let users: Vec<User> = users::table
+        .filter(users::id.eq(any(user_ids)))
+        .load(conn)?;
+
+    let users: HashMap<i32, User> = users.into_iter().map(|user| (user.id, user)).collect();
+
+    // Make a list of all related crates
+    let crate_ids: Vec<_> = crate_owner_invitations
+        .iter()
+        .map(|invitation| invitation.crate_id)
+        .collect();
+
+    // Load all related crates
+    let crates: Vec<_> = crates::table
+        .select((crates::id, crates::name))
+        .filter(crates::id.eq(any(crate_ids)))
+        .load(conn)?;
+
+    let crates: HashMap<i32, String> = crates.into_iter().collect();
+
+    // Turn `CrateOwnerInvitation` list into `EncodableCrateOwnerInvitation` list
     let crate_owner_invitations = crate_owner_invitations
         .into_iter()
-        .map(|i| EncodableCrateOwnerInvitation::from(i, conn))
+        .map(|invitation| {
+            let inviter_id = invitation.invited_by_user_id;
+            let inviter_name = users
+                .get(&inviter_id)
+                .map(|user| user.gh_login.clone())
+                .unwrap_or_default();
+
+            let crate_name = crates
+                .get(&invitation.crate_id)
+                .map(|name| name.clone())
+                .unwrap_or_else(|| String::from("(unknown crate name)"));
+
+            EncodableCrateOwnerInvitation::from(invitation, inviter_name, crate_name)
+        })
+        .collect();
+
+    // Turn `User` list into `EncodablePublicUser` list
+    let users = users
+        .into_iter()
+        .map(|(_, user)| EncodablePublicUser::from(user))
         .collect();
 
     #[derive(Serialize)]
     struct R {
         crate_owner_invitations: Vec<EncodableCrateOwnerInvitation>,
+        users: Vec<EncodablePublicUser>,
     }
     Ok(req.json(&R {
         crate_owner_invitations,
+        users,
     }))
 }
 

src/models/crate_owner_invitation.rs

@@ -1,7 +1,6 @@
 use chrono::NaiveDateTime;
-use diesel::prelude::*;
 
-use crate::schema::{crate_owner_invitations, crates, users};
+use crate::schema::crate_owner_invitations;
 
 /// The model representing a row in the `crate_owner_invitations` database table.
 #[derive(Clone, Debug, PartialEq, Eq, Identifiable, Queryable)]
@@ -22,21 +21,3 @@ pub struct NewCrateOwnerInvitation {
     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)"))
-    }
-}

src/tests/owners.rs

@@ -330,14 +330,31 @@ fn invitations_list() {
     let user = app.db_new_user("invited_user");
     token.add_user_owner("invited_crate", "invited_user");
 
-    let json = user.list_invitations();
-    assert_eq!(json.crate_owner_invitations.len(), 1);
+    let response = user.get::<()>("/api/v1/me/crate_owner_invitations");
+    assert_eq!(response.status(), StatusCode::OK);
+
+    let json = response.json();
     assert_eq!(
-        json.crate_owner_invitations[0].invited_by_username,
-        owner.gh_login
+        json,
+        json!({
+            "crate_owner_invitations": [{
+                "crate_id": krate.id,
+                "crate_name": "invited_crate",
+                // this value changes with each test run so we can't use a fixed value here
+                "created_at": &json["crate_owner_invitations"][0]["created_at"],
+                "invited_by_username": owner.gh_login,
+                "invitee_id": user.as_model().id,
+                "inviter_id": owner.id,
+            }],
+            "users": [{
+                "avatar": null,
+                "id": owner.id,
+                "login": "foo",
+                "name": null,
+                "url": "https://github.com/foo",
+            }],
+        })
     );
-    assert_eq!(json.crate_owner_invitations[0].crate_name, "invited_crate");
-    assert_eq!(json.crate_owner_invitations[0].crate_id, krate.id);
 }
 
 /*  Given a user inviting a different user to be a crate

src/views.rs

@@ -1,5 +1,4 @@
 use chrono::NaiveDateTime;
-use diesel::PgConnection;
 use std::collections::HashMap;
 use url::Url;
 
@@ -76,6 +75,8 @@ pub struct EncodableCategoryWithSubcategories {
 /// The serialization format for the `CrateOwnerInvitation` model.
 #[derive(Deserialize, Serialize, Debug)]
 pub struct EncodableCrateOwnerInvitation {
+    pub invitee_id: i32,
+    pub inviter_id: i32,
     pub invited_by_username: String,
     pub crate_name: String,
     pub crate_id: i32,
@@ -84,10 +85,16 @@ pub struct EncodableCrateOwnerInvitation {
 }
 
 impl EncodableCrateOwnerInvitation {
-    pub fn from(invitation: CrateOwnerInvitation, conn: &PgConnection) -> Self {
+    pub fn from(
+        invitation: CrateOwnerInvitation,
+        inviter_name: String,
+        crate_name: String,
+    ) -> Self {
         Self {
-            invited_by_username: invitation.invited_by_username(conn),
-            crate_name: invitation.crate_name(conn),
+            invitee_id: invitation.invited_user_id,
+            inviter_id: invitation.invited_by_user_id,
+            invited_by_username: inviter_name,
+            crate_name,
             crate_id: invitation.crate_id,
             created_at: invitation.created_at,
         }
@@ -791,6 +798,8 @@ mod tests {
     #[test]
     fn crate_owner_invitation_serializes_to_rfc3339() {
         let inv = EncodableCrateOwnerInvitation {
+            invitee_id: 1,
+            inviter_id: 2,
             invited_by_username: "".to_string(),
             crate_name: "".to_string(),
             crate_id: 123,