Record the verified email of the version publisher

If there is one, because we're still in the optional stage, but we can
start recording them now if possible.

Author: carols10cents

src/bin/update-downloads.rs

@@ -149,7 +149,9 @@ mod test {
             user_id,
         )
         .unwrap();
-        let version = version.save(conn, &[]).unwrap();
+        let version = version
+            .save(conn, &[], Some("[email protected]".into()))
+            .unwrap();
         (krate, version)
     }
 

src/controllers/krate/publish.rs

@@ -66,7 +66,8 @@ pub fn publish(req: &mut dyn Request) -> CargoResult<Response> {
     let conn = app.diesel_database.get()?;
 
     let mut other_warnings = vec![];
-    if !user.has_verified_email(&conn)? {
+    let verified_email_address = user.verified_email(&conn)?;
+    if verified_email_address.is_none() {
         other_warnings.push(String::from(
             "You do not currently have a verified email address associated with your crates.io \
              account. Starting 2019-02-28, a verified email will be required to publish crates. \
@@ -148,7 +149,7 @@ pub fn publish(req: &mut dyn Request) -> CargoResult<Response> {
             file_length as i32,
             user.id,
         )?
-        .save(&conn, &new_crate.authors)?;
+        .save(&conn, &new_crate.authors, verified_email_address)?;
 
         // Link this new version to all dependencies
         let git_deps = dependency::add_dependencies(&conn, &new_crate.deps, version.id)?;

src/models/user.rs

@@ -5,7 +5,7 @@ use std::borrow::Cow;
 use crate::app::App;
 use crate::util::CargoResult;
 
-use crate::models::{Crate, CrateOwner, NewEmail, Owner, OwnerKind, Rights};
+use crate::models::{Crate, CrateOwner, Email, NewEmail, Owner, OwnerKind, Rights};
 use crate::schema::{crate_owners, emails, users};
 use crate::views::{EncodablePrivateUser, EncodablePublicUser};
 
@@ -162,15 +162,12 @@ impl User {
         Ok(best)
     }
 
-    pub fn has_verified_email(&self, conn: &PgConnection) -> CargoResult<bool> {
-        use diesel::dsl::exists;
-        let email_exists = diesel::select(exists(
-            emails::table
-                .filter(emails::user_id.eq(self.id))
-                .filter(emails::verified.eq(true)),
-        ))
-        .get_result(&*conn)?;
-        Ok(email_exists)
+    pub fn verified_email(&self, conn: &PgConnection) -> CargoResult<Option<String>> {
+        Ok(Email::belonging_to(self)
+            .select(emails::email)
+            .filter(emails::verified.eq(true))
+            .first::<String>(&*conn)
+            .optional()?)
     }
 
     /// Converts this `User` model into an `EncodablePrivateUser` for JSON serialization.

src/models/version.rs

@@ -148,7 +148,13 @@ impl NewVersion {
         Ok(new_version)
     }
 
-    pub fn save(&self, conn: &PgConnection, authors: &[String]) -> CargoResult<Version> {
+    // TODO: change `published_by_email` to be `String` after 2019-02-28
+    pub fn save(
+        &self,
+        conn: &PgConnection,
+        authors: &[String],
+        published_by_email: Option<String>,
+    ) -> CargoResult<Version> {
         use crate::schema::version_authors::{name, version_id};
         use crate::schema::versions::dsl::*;
         use diesel::dsl::exists;
@@ -170,6 +176,16 @@ impl NewVersion {
                 .values(self)
                 .get_result::<Version>(conn)?;
 
+            // TODO: Remove the `if` around this insert after 2019-02-28
+            if let Some(published_by_email) = published_by_email {
+                insert_into(versions_published_by::table)
+                    .values((
+                        versions_published_by::version_id.eq(version.id),
+                        versions_published_by::email.eq(published_by_email),
+                    ))
+                    .execute(conn)?;
+            }
+
             let new_authors = authors
                 .iter()
                 .map(|s| (version_id.eq(version.id), name.eq(s)))

src/tests/builders.rs

@@ -90,7 +90,7 @@ impl<'a> VersionBuilder<'a> {
             self.size,
             published_by,
         )?
-        .save(connection, &[])?;
+        .save(connection, &[], Some("[email protected]".into()))?;
 
         if self.yanked {
             vers = update(&vers)

src/tests/krate.rs

@@ -6,7 +6,7 @@ use crate::{
 use cargo_registry::{
     git,
     models::{krate::MAX_NAME_LENGTH, Category, Crate},
-    schema::{api_tokens, crates, emails, metadata, versions},
+    schema::{api_tokens, crates, emails, metadata, versions, versions_published_by},
     views::{
         EncodableCategory, EncodableCrate, EncodableDependency, EncodableKeyword, EncodableVersion,
         EncodableVersionDownload,
@@ -1077,7 +1077,7 @@ fn new_krate_with_readme() {
 // See https://github.com/rust-lang/crates-io-cargo-teams/issues/8
 #[test]
 fn new_krate_without_any_email_warns() {
-    let (_, _, _, token) = TestApp::with_proxy().with_token();
+    let (app, _, _, token) = TestApp::with_proxy().with_token();
 
     let crate_to_publish = PublishBuilder::new("foo_no_email");
 
@@ -1086,6 +1086,14 @@ fn new_krate_without_any_email_warns() {
     assert_eq!(json.warnings.other[0], "You do not currently have a verified email address \
     associated with your crates.io account. Starting 2019-02-28, a verified email will be required \
     to publish crates. Visit https://crates.io/me to set and verify your email address.");
+
+    // Don't record a verified email if there isn't one
+    app.db(|conn| {
+        let email = versions_published_by::table
+            .select(versions_published_by::email)
+            .first::<String>(conn);
+        assert!(email.is_err());
+    });
 }
 
 // This warning will soon become a hard error.
@@ -1112,6 +1120,14 @@ fn new_krate_with_unverified_email_warns() {
     assert_eq!(json.warnings.other[0], "You do not currently have a verified email address \
     associated with your crates.io account. Starting 2019-02-28, a verified email will be required \
     to publish crates. Visit https://crates.io/me to set and verify your email address.");
+
+    // Don't record a verified email if there isn't one
+    app.db(|conn| {
+        let email = versions_published_by::table
+            .select(versions_published_by::email)
+            .first::<String>(conn);
+        assert!(email.is_err());
+    });
 }
 
 #[test]
@@ -1137,6 +1153,15 @@ fn new_krate_with_verified_email_doesnt_warn() {
 
     let json = token.publish(crate_to_publish).good();
     assert_eq!(json.warnings.other.len(), 0);
+
+    // Record a verified email because there is one
+    app.db(|conn| {
+        let email = versions_published_by::table
+            .select(versions_published_by::email)
+            .first::<String>(conn)
+            .unwrap();
+        assert_eq!(email, "[email protected]");
+    });
 }
 
 #[test]