Use GraphQl to query all users (#120)

Author: lenguyenthanh

Cargo.toml

@@ -19,7 +19,7 @@ color-backtrace = "0.4.0"
 pretty_env_logger = "0.4.0"
 prettytable-rs = "0.8.0"
 
-reqwest = { version = "0.10.3", features = ["blocking", "json", "gzip"] }
+reqwest = { version = "0.10.4", features = ["blocking", "json", "gzip"] }
 graphql_client = "0.9.0"
 
 dirs = "2.0"

src/commands/show_users.rs

@@ -1,28 +1,28 @@
 use super::common;
 use crate::github;
-use anyhow::{anyhow, Result};
+use anyhow::Result;
 use structopt::StructOpt;
 
 #[derive(Debug, StructOpt)]
 /// Show all users in an organisation
 pub struct ShowUsersArgs {
     #[structopt(long, short, default_value = "divvun")]
     pub organisation: String,
-    #[structopt(long, short, default_value = "all", parse(try_from_str = parse_role))]
-    /// Filter members returned by their role.
-    ///
-    /// Can be one of:
-    /// * all - All members of the organization, regardless of role.
-    /// * admin - Organization owners.
-    /// * member - Non-owner organization members.
-    pub role: String,
+    //#[structopt(long, short, default_value = "all", parse(try_from_str = parse_role))]
+    // Filter members returned by their role.
+    //
+    // Can be one of:
+    // * all - All members of the organization, regardless of role.
+    // * admin - Organization owners.
+    // * member - Non-owner organization members.
+    //pub role: String,
 }
 
 impl ShowUsersArgs {
     pub fn run(&self) -> Result<()> {
         let user_token = common::user_token()?;
 
-        let result = github::get_org_members(&self.organisation, &self.role, &user_token);
+        let result = github::get_org_members(&self.organisation, &user_token);
 
         match result {
             Ok(users) => print_results(&users),
@@ -40,12 +40,12 @@ fn print_results(users: &[github::OrgMember]) {
     }
 }
 
-fn parse_role(src: &str) -> Result<String> {
-    let roles = ["all", "admin", "member"];
-    let src = src.to_lowercase();
-    if roles.contains(&src.as_str()) {
-        return Ok(src);
-    }
+//fn parse_role(src: &str) -> Result<String> {
+//let roles = ["all", "admin", "member"];
+//let src = src.to_lowercase();
+//if roles.contains(&src.as_str()) {
+//return Ok(src);
+//}
 
-    Err(anyhow!("role must be one of {:?}", roles))
-}
+//Err(anyhow!("role must be one of {:?}", roles))
+//}

src/github/graphql.rs

@@ -38,6 +38,14 @@ struct RepositoryDefaultBranch;
 )]
 struct OrganizationRepositoriesWithTopics;
 
+#[derive(GraphQLQuery)]
+#[graphql(
+    schema_path = "github.graphql",
+    query_path = "user_query.graphql",
+    response_derives = "Debug"
+)]
+struct OrganizationMembers;
+
 fn query<T: Serialize + ?Sized>(token: &str, body: &T) -> Result<req::Response, reqwest::Error> {
     let client = req::Client::new();
     client
@@ -74,6 +82,74 @@ pub fn is_valid_token(token: &str) -> anyhow::Result<String> {
     Ok(username.to_string())
 }
 
+#[derive(Debug)]
+pub struct OrgMember {
+    pub login: String,
+    pub url: String,
+    //pub role: String,
+}
+
+//#[derive(Debug)]
+//pub enum OrgRole {
+//Member,
+//Admin
+//}
+
+pub fn get_org_members(org: &str, token: &str) -> anyhow::Result<Vec<OrgMember>> {
+    get_org_members_rec(org, token, None)
+}
+
+fn get_org_members_rec(
+    org: &str,
+    token: &str,
+    after: Option<String>,
+) -> anyhow::Result<Vec<OrgMember>> {
+    let q = OrganizationMembers::build_query(organization_members::Variables {
+        login: org.to_string(),
+        after,
+    });
+
+    let res = query(token, &q)?;
+
+    let response_status = res.status();
+    if response_status == reqwest::StatusCode::UNAUTHORIZED {
+        return Err(Unauthorized.into());
+    }
+
+    let response_body: Response<organization_members::ResponseData> = res.json()?;
+
+    let org_data = response_body
+        .data
+        .as_ref()
+        .ok_or(InvalidRepoResponse)?
+        .organization
+        .as_ref()
+        .ok_or(InvalidRepoResponse)?;
+
+    let members = org_data.members_with_role.nodes.as_ref();
+
+    let mut list_member: Vec<OrgMember> = members
+        .ok_or(NoMembersFound)?
+        .iter()
+        .filter_map(|user| user.as_ref())
+        .map(|x| OrgMember {
+            login: x.login.to_string(),
+            url: x.url.to_string(),
+        })
+        .collect();
+
+    let page_info = &org_data.members_with_role.page_info;
+
+    if page_info.has_next_page {
+        let after = page_info.end_cursor.as_ref().map(|x| x.to_string());
+        match get_org_members_rec(org, token, after) {
+            Ok(mut l) => list_member.append(&mut l),
+            Err(e) => return Err(e),
+        }
+    }
+    Ok(list_member)
+}
+
 fn list_org_repos_rec(
     token: &str,
     org: &str,

src/github/models.rs

@@ -36,6 +36,10 @@ pub struct InvalidRepoResponse;
 #[error("no repositories found")]
 pub struct NoReposFound;
 
+#[derive(thiserror::Error, Debug)]
+#[error("no members found")]
+pub struct NoMembersFound;
+
 #[derive(thiserror::Error, Debug)]
 #[error("No default branch")]
 pub struct NoDefaultBranch;

src/github/rest.rs

@@ -677,30 +677,30 @@ struct SetRepoToTeamBody {
 }
 
 // https://developer.github.com/v3/orgs/members/#members-list
-pub fn get_org_members(org: &str, role: &str, token: &str) -> Result<Vec<OrgMember>> {
-    let url = format!("https://api.github.com/orgs/{}/members?role={}", org, role);
+//pub fn get_org_members(org: &str, role: &str, token: &str) -> Result<Vec<OrgMember>> {
+//let url = format!("https://api.github.com/orgs/{}/members?role={}", org, role);
 
-    let response = get(&url, token, None)?;
+//let response = get(&url, token, None)?;
 
-    let status = response.status();
+//let status = response.status();
 
-    if status == StatusCode::UNAUTHORIZED {
-        return Err(models::Unauthorized.into());
-    }
+//if status == StatusCode::UNAUTHORIZED {
+//return Err(models::Unauthorized.into());
+//}
 
-    if !status.is_success() {
-        return Err(models::Unsuccessful(status).into());
-    }
+//if !status.is_success() {
+//return Err(models::Unsuccessful(status).into());
+//}
 
-    let response_body: Vec<OrgMember> = response.json()?;
-    Ok(response_body)
-}
+//let response_body: Vec<OrgMember> = response.json()?;
+//Ok(response_body)
+//}
 
-#[derive(Deserialize, Debug)]
-pub struct OrgMember {
-    pub login: String,
-    pub url: String,
-}
+//#[derive(Deserialize, Debug)]
+//pub struct OrgMember {
+//pub login: String,
+//pub url: String,
+//}
 
 fn process_response(response: &req::Response) -> Result<&req::Response> {
     let status = response.status();

user_query.graphql

@@ -54,3 +54,19 @@ query OrganizationRepositoriesWithTopics($login: String!, $after: String) {
     }
   }
 }
+
+query OrganizationMembers($login: String!, $after: String) {
+  organization(login: $login) {
+    membersWithRole(first: 30, after: $after) {
+      nodes {
+        login,
+        email,
+        url,
+      }
+      pageInfo {
+        endCursor
+        hasNextPage
+      }
+    }
+  }
+}