Track GitHub ids instead of logins

These are stable across renames on GitHub, and help track on GitHub account.

Author: alexcrichton

src/bin/migrate.rs

@@ -741,6 +741,7 @@ fn migrations() -> Vec<Migration> {
         ),
 
         Migration::add_column(20160811151953, "users", "gh_id", "INTEGER"),
+        index(20160811151954, "users", "gh_id"),
     ];
     // NOTE: Generate a new id via `date +"%Y%m%d%H%M%S"`
 

src/bin/update-downloads.rs

@@ -149,7 +149,7 @@ mod test {
     }
 
     fn user(conn: &postgres::Transaction) -> User{
-        User::find_or_insert(conn, "login", None, None, None,
+        User::find_or_insert(conn, 2, "login", None, None, None,
                              "access_token", "api_token").unwrap()
     }
 

src/tests/all.rs

@@ -168,6 +168,7 @@ static NEXT_ID: AtomicUsize = ATOMIC_USIZE_INIT;
 fn user(login: &str) -> User {
     User {
         id: NEXT_ID.fetch_add(1, Ordering::SeqCst) as i32,
+        gh_id: NEXT_ID.fetch_add(1, Ordering::SeqCst) as i32,
         gh_login: login.to_string(),
         email: None,
         name: None,
@@ -197,6 +198,7 @@ fn krate(name: &str) -> Crate {
 
 fn mock_user(req: &mut Request, u: User) -> User {
     let u = User::find_or_insert(req.tx().unwrap(),
+                                 u.gh_id,
                                  &u.gh_login,
                                  u.email.as_ref().map(|s| &s[..]),
                                  u.name.as_ref().map(|s| &s[..]),

src/tests/user.rs

@@ -35,16 +35,23 @@ fn user_insert() {
     let conn = t!(app.database.get());
     let tx = t!(conn.transaction());
 
-    let user = t!(User::find_or_insert(&tx, "foo", None, None, None, "bar", "baz"));
+    let user = t!(User::find_or_insert(&tx, 1, "foo", None, None, None, "bar", "baz"));
     assert_eq!(t!(User::find_by_api_token(&tx, "baz")), user);
     assert_eq!(t!(User::find(&tx, user.id)), user);
 
-    assert_eq!(t!(User::find_or_insert(&tx, "foo", None, None, None,
+    assert_eq!(t!(User::find_or_insert(&tx, 1, "foo", None, None, None,
                                        "bar", "api")), user);
-    let user2 = t!(User::find_or_insert(&tx, "foo", None, None, None,
+    let user2 = t!(User::find_or_insert(&tx, 1, "foo", None, None, None,
                                         "baz", "api"));
     assert!(user != user2);
+    assert_eq!(user.id, user2.id);
     assert_eq!(user2.gh_access_token, "baz");
+
+    let user3 = t!(User::find_or_insert(&tx, 1, "bar", None, None, None,
+                                        "baz", "api"));
+    assert!(user != user3);
+    assert_eq!(user.id, user3.id);
+    assert_eq!(user3.gh_login, "bar");
 }
 
 #[test]
@@ -68,7 +75,7 @@ fn reset_token() {
     let mut req = ::req(app, Method::Put, "/me/reset_token");
     let user = {
         let tx = RequestTransaction::tx(&mut req as &mut Request);
-        User::find_or_insert(tx.unwrap(), "foo", None,
+        User::find_or_insert(tx.unwrap(), 1, "foo", None,
                              None, None, "bar", "baz").unwrap()
     };
     ::mock_user(&mut req, user.clone());

src/user/mod.rs

@@ -25,6 +25,7 @@ pub mod middleware;
 pub struct User {
     pub id: i32,
     pub gh_login: String,
+    pub gh_id: i32,
     pub name: Option<String>,
     pub email: Option<String>,
     pub avatar: Option<String>,
@@ -68,6 +69,7 @@ impl User {
 
     /// Updates a user or inserts a new user into the database.
     pub fn find_or_insert(conn: &GenericConnection,
+                          id: i32,
                           login: &str,
                           email: Option<&str>,
                           name: Option<&str>,
@@ -82,26 +84,32 @@ impl User {
                                       SET gh_access_token = $1,
                                           email = $2,
                                           name = $3,
-                                          gh_avatar = $4
-                                      WHERE gh_login = $5
+                                          gh_avatar = $4,
+                                          gh_login = $5
+                                      WHERE gh_id = $6
                                       RETURNING *"));
         let rows = try!(stmt.query(&[&access_token,
-                                     &email, &name, &avatar,
-                                     &login]));
+                                     &email,
+                                     &name,
+                                     &avatar,
+                                     &login,
+                                     &id]));
         match rows.iter().next() {
             Some(ref row) => return Ok(Model::from_row(row)),
             None => {}
         }
         let stmt = try!(conn.prepare("INSERT INTO users
                                       (email, gh_access_token, api_token,
-                                       gh_login, name, gh_avatar)
-                                      VALUES ($1, $2, $3, $4, $5, $6)
+                                       gh_login, name, gh_avatar, gh_id)
+                                      VALUES ($1, $2, $3, $4, $5, $6, $7)
                                       RETURNING *"));
         let rows = try!(stmt.query(&[&email,
                                      &access_token,
                                      &api_token,
                                      &login,
-                                     &name, &avatar]));
+                                     &name,
+                                     &avatar,
+                                     &id]));
         Ok(Model::from_row(&try!(rows.iter().next().chain_error(|| {
             internal("no user with email we just found")
         }))))
@@ -115,7 +123,7 @@ impl User {
     /// Converts this `User` model into an `EncodableUser` for JSON serialization.
     pub fn encodable(self) -> EncodableUser {
         let User { id, email, api_token: _, gh_access_token: _,
-                   name, gh_login, avatar } = self;
+                   name, gh_login, avatar, gh_id: _ } = self;
         EncodableUser {
             id: id,
             email: email,
@@ -134,6 +142,7 @@ impl Model for User {
             gh_access_token: row.get("gh_access_token"),
             api_token: row.get("api_token"),
             gh_login: row.get("gh_login"),
+            gh_id: row.get("gh_id"),
             name: row.get("name"),
             avatar: row.get("gh_avatar"),
         }
@@ -218,6 +227,7 @@ pub fn github_access_token(req: &mut Request) -> CargoResult<Response> {
         email: Option<String>,
         name: Option<String>,
         login: String,
+        id: i32,
         avatar_url: Option<String>,
     }
 
@@ -233,6 +243,7 @@ pub fn github_access_token(req: &mut Request) -> CargoResult<Response> {
     // Into the database!
     let api_token = User::new_api_token();
     let user = try!(User::find_or_insert(try!(req.tx()),
+                                         ghuser.id,
                                          &ghuser.login,
                                          ghuser.email.as_ref()
                                                .map(|s| &s[..]),