more progress

Gankra · Gankra · commit 57b53e78c399 · 2015-08-11T16:00:53.000-07:00
diff --git a/src/bin/migrate.rs b/src/bin/migrate.rs
@@ -463,6 +463,7 @@ fn migrations() -> Vec<Migration> {
             "ALTER TABLE crate_owners RENAME user_id TO owner_id",
             "ALTER TABLE crate_owners RENAME owner_id TO user_id",
         ),
+        undo_foreign_key(20150804170130, "crate_owners", "user_id", "users (id)"),
     ];
     // NOTE: Generate a new id via `date +"%Y%m%d%H%M%S"`
 
@@ -484,6 +485,16 @@ fn migrations() -> Vec<Migration> {
         Migration::run(id, &add, &rm)
     }
 
+    fn undo_foreign_key(id: i64, table: &str, column: &str,
+                   references: &str) -> Migration {
+        let add = format!("ALTER TABLE {table} ADD CONSTRAINT fk_{table}_{col}
+                                 FOREIGN KEY ({col}) REFERENCES {reference}",
+                          table = table, col = column, reference = references);
+        let rm = format!("ALTER TABLE {table} DROP CONSTRAINT fk_{table}_{col}",
+                          table = table, col = column);
+        Migration::run(id, &rm, &add)
+    }
+
     fn index(id: i64, table: &str, column: &str) -> Migration {
         let add = format!("CREATE INDEX index_{table}_{column}
                            ON {table} ({column})",
diff --git a/src/http.rs b/src/http.rs
@@ -0,0 +1,20 @@
+use curl;
+use oauth2::*;
+
+pub fn github(url: &str, auth: &Token)
+    -> Result<curl::http::Response, curl::ErrCode> {
+    curl::http::handle()
+     .get(url)
+     .header("Accept", "application/vnd.github.v3+json")
+     .header("User-Agent", "hello!")
+     .auth_with(auth)
+     .exec()
+}
+
+pub fn token(token: String) -> Token {
+    Token {
+        access_token: token,
+        scopes: Vec::new(),
+        token_type: String::new(),
+    }
+}
diff --git a/src/krate.rs b/src/krate.rs
@@ -178,7 +178,7 @@ impl Crate {
                            (crate_id, owner_id, created_by, created_at,
                              updated_at, deleted, owner_kind)
                            VALUES ($1, $2, $2, $3, $3, FALSE, $4)",
-                          &[&ret.id, &user_id, &now, &(OwnerKind::User as u32)]));
+                          &[&ret.id, &user_id, &now, &(OwnerKind::User as i32)]));
         return Ok(ret);
 
         fn validate_url(url: Option<&str>, field: &str) -> CargoResult<()> {
@@ -299,15 +299,15 @@ impl Crate {
                                       WHERE crate_owners.crate_id = $1
                                         AND crate_owners.deleted = FALSE
                                         AND crate_owners.owner_kind = $2"));
-        let user_rows = try!(stmt.query(&[&self.id, &(OwnerKind::User as u32)]));
+        let user_rows = try!(stmt.query(&[&self.id, &(OwnerKind::User as i32)]));
 
         let stmt = try!(conn.prepare("SELECT * FROM teams
                                       INNER JOIN crate_owners
                                          ON crate_owners.owner_id = teams.id
                                       WHERE crate_owners.crate_id = $1
                                         AND crate_owners.deleted = FALSE
                                         AND crate_owners.owner_kind = $2"));
-        let team_rows = try!(stmt.query(&[&self.id, &(OwnerKind::Team as u32)]));
+        let team_rows = try!(stmt.query(&[&self.id, &(OwnerKind::Team as i32)]));
 
         let mut owners = vec![];
         owners.extend(user_rows.iter().map(|r| Owner::User(Model::from_row(&r))));
diff --git a/src/lib.rs b/src/lib.rs
@@ -57,6 +57,7 @@ pub mod user;
 pub mod owner;
 pub mod util;
 pub mod version;
+pub mod http;
 mod licenses;
 
 #[derive(PartialEq, Eq, Clone, Copy)]
diff --git a/src/owner.rs b/src/owner.rs
@@ -1,21 +1,11 @@
 use {Model, User};
 use util::{RequestUtils, CargoResult, internal, ChainError, human};
 use db::Connection;
-use curl;
 use pg::rows::Row;
 use rustc_serialize::json;
 use util::errors::NotFound;
 use std::str;
-
-pub fn json_http(url: &str, auth_token: &str)
-    -> Result<curl::http::Response, curl::ErrCode> {
-    curl::http::handle()
-     .get(url)
-     .header("Accept", "application/vnd.github.v3+json")
-     .header("User-Agent", "hello!")
-     .header("Authorization", &format!("token {}", auth_token))
-     .exec()
-}
+use http;
 
 #[repr(u32)]
 pub enum OwnerKind {
@@ -45,6 +35,7 @@ pub struct Team {
 #[derive(RustcDecodable, RustcEncodable)]
 pub struct EncodableOwner {
     pub id: i32,
+    // TODO: duplicate this field with better name
     pub login: String,
     pub kind: String,
     pub email: Option<String>,
@@ -114,8 +105,9 @@ impl Team {
                                    c)));
         }
 
-        let resp = try!(json_http(&format!("https://api.github.com/orgs/{}/teams", org_name),
-                                  &req_user.gh_access_token));
+        let resp = try!(http::github(
+            &format!("https://api.github.com/orgs/{}/teams", org_name),
+            &http::token(req_user.gh_access_token.clone())));
 
         match resp.get_code() {
             200 => {} // Ok!
@@ -159,9 +151,7 @@ impl Team {
             human(format!("could not find the github team {}/{}", org_name, team_name))
         }));
 
-        // mock Team (only need github_id to check team status)
-        let team = Team { github_id: github_id, id: 0, name: String::new() };
-        if !try!(team.contains_user(req_user)) {
+        if !try!(team_with_gh_id_contains_user(github_id, req_user)) {
             return Err(human("only members of a team can add it as an owner"));
         }
 
@@ -185,48 +175,52 @@ impl Team {
     /// the answer. If this is not the case, then we could accidentally leak
     /// private membership information here.
     pub fn contains_user(&self, user: &User) -> CargoResult<bool> {
-        // GET teams/:team_id/memberships/:user_name
-        // check that "state": "active"
+        team_with_gh_id_contains_user(self.github_id, user)
+    }
+}
 
-        let resp = try!(json_http(&format!("https://api.github.com/teams/{}/memberships/{}",
-                                            self.github_id, &user.gh_login),
-                                  &user.gh_access_token));
+fn team_with_gh_id_contains_user(github_id: i32, user: &User) -> CargoResult<bool> {
+    // GET teams/:team_id/memberships/:user_name
+    // check that "state": "active"
 
-        match resp.get_code() {
-            200 => {} // Ok!
-            404 => {
-                // Yes, this is actually how "no membership" is signaled
-                return Ok(false);
-            }
-            403 => {
-                return Err(human("It looks like you don't have permission \
-                                  to query an organization that owns this \
-                                  crate. You may need to re-authenticate on \
-                                  crates.io to grant permission to read \
-                                  github org memberships. Just go to \
-                                  https://crates.io/login"));
-            }
-            _ => {
-                return Err(internal(format!("didn't get a 200 result from github: {}",
-                                        resp)))
-            }
-        }
+    let resp = try!(http::github(
+        &format!("https://api.github.com/teams/{}/memberships/{}", &github_id, &user.gh_login),
+        &http::token(user.gh_access_token.clone())));
 
-        #[derive(RustcDecodable)]
-        struct Membership {
-            state: String,
+    match resp.get_code() {
+        200 => {} // Ok!
+        404 => {
+            // Yes, this is actually how "no membership" is signaled
+            return Ok(false);
         }
-        let json = try!(str::from_utf8(resp.get_body()).ok().chain_error(||{
-            internal("github didn't send a utf8-response")
-        }));
-        let membership: Membership = try!(json::decode(json).chain_error(|| {
-            internal("github didn't send a valid json response")
-        }));
+        403 => {
+            return Err(human("It looks like you don't have permission \
+                              to query an organization that owns this \
+                              crate. You may need to re-authenticate on \
+                              crates.io to grant permission to read \
+                              github org memberships. Just go to \
+                              https://crates.io/login"));
+        }
+        _ => {
+            return Err(internal(format!("didn't get a 200 result from github: {}",
+                                    resp)))
+        }
+    }
 
-        // There is also `state: pending` for which we could possibly give
-        // some feedback, but it's not obvious how that should work.
-        Ok(membership.state == "active")
+    #[derive(RustcDecodable)]
+    struct Membership {
+        state: String,
     }
+    let json = try!(str::from_utf8(resp.get_body()).ok().chain_error(||{
+        internal("github didn't send a utf8-response")
+    }));
+    let membership: Membership = try!(json::decode(json).chain_error(|| {
+        internal("github didn't send a valid json response")
+    }));
+
+    // There is also `state: pending` for which we could possibly give
+    // some feedback, but it's not obvious how that should work.
+    Ok(membership.state == "active")
 }
 
 impl Model for Team {
@@ -293,8 +287,8 @@ impl Owner {
 
     pub fn kind(&self) -> i32 {
         match *self {
-            Owner::User(_) => 0,
-            Owner::Team(_) => 1,
+            Owner::User(_) => OwnerKind::User as i32,
+            Owner::Team(_) => OwnerKind::Team as i32,
         }
     }
 
diff --git a/src/tests/all.rs b/src/tests/all.rs
@@ -64,6 +64,7 @@ mod user;
 mod record;
 mod git;
 mod version;
+mod team;
 
 fn app() -> (record::Bomb, Arc<App>, conduit_middleware::MiddlewareBuilder) {
     struct NoCommit;
diff --git a/src/tests/team.rs b/src/tests/team.rs
diff --git a/src/user/mod.rs b/src/user/mod.rs
