Add support for summary command (#42)

Cargo.toml

@@ -13,3 +13,4 @@ serde_json = "1.0.48"
 serde = {version = "1.0.104", features = ["derive"] }
 dirs = "2.0.2"
 comfy-table = "0.1.0"
+console="0.10.0"

src/diffs.rs

@@ -12,6 +12,13 @@ pub fn process_diff_command(_matches: &ArgMatches, config: &FabConfig) {
         return;
     }
 
+    let result = get_authored_diffs(config).expect("Couldn't fetch diffs");
+
+    render_diffs(config, &result);
+}
+
+/// Get diffs that are authored by the user.
+pub fn get_authored_diffs(config: &FabConfig) -> Result<Vec<Revision>, String> {
     let json_body = json!({
             "queryKey": "authored",
             "api.token": config.api_token,
@@ -21,33 +28,50 @@ pub fn process_diff_command(_matches: &ArgMatches, config: &FabConfig) {
 
     let result = auth::send::<RevisionData>(config, reqwest::blocking::Client::new()
         .post(&url)
-        .form(&json_body))
-        .expect("Couldn't fetch diffs");
-
-    let revisions: Vec<&Revision> = result.data.iter().filter(|rev| !rev.fields.status.closed).collect();
+        .form(&json_body));
 
-    render_diffs(config, &revisions);
+    match result {
+        Ok(result) => {
+            let revisions = result.data
+                .into_iter()
+                .filter(|rev| !rev.fields.status.closed)
+                .collect();
+            Result::Ok(revisions)
+        },
+        Err(_err) => {
+            Result::Err(String::from("Couldn't fetch authored diffs"))
+        }
+    }
 }
 
-fn process_diffs_needs_review(config: &FabConfig) {
+/// Get the diffs that needs review from the user.
+pub fn get_needs_review_diffs(config: &FabConfig) -> Result<Vec<Revision>, String> {
     let json_body = json!({
             "api.token": config.api_token,
             "constraints[reviewerPHIDs][0]": config.phid
         });
 
     let url = format!("{}{}", config.hosted_instance, DIFFERENTIAL_SEARCH_URL);
 
-    let response = auth::send::<RevisionData>(config, reqwest::blocking::Client::new()
+    let result = auth::send::<RevisionData>(config, reqwest::blocking::Client::new()
         .post(&url)
-        .form(&json_body))
-        .expect("Failed to fetch response for needs-review diffs");
+        .form(&json_body));
 
-    let revisions = response.data.iter().filter(|rev| !rev.fields.status.closed).collect();
-    render_diffs(config, &revisions)
 
+    match result {
+        Ok(response) => {
+            let revisions = response.data
+                .into_iter()
+                .filter(|rev| !rev.fields.status.closed)
+                .collect();
+
+            Result::Ok(revisions)
+        },
+        Err(_err) => Result::Err(String::from("Failed to fetch needs-review diffs"))
+    }
 }
 
-fn render_diffs(config: &FabConfig, revisions: &Vec<&Revision>) {
+pub fn render_diffs(config: &FabConfig, revisions: &[Revision]) {
     let mut table = Table::new();
 
     table
@@ -68,3 +92,11 @@ fn render_diffs(config: &FabConfig, revisions: &Vec<&Revision>) {
     }
     println!("{}", table);
 }
+
+
+fn process_diffs_needs_review(config: &FabConfig) {
+    let revisions = get_needs_review_diffs(config).expect("Failed to fetch response for needs-review diffs");
+
+    // let revisions = response.data.iter().filter(|rev| !rev.fields.status.closed).collect();
+    render_diffs(config, &revisions)
+}

src/main.rs

@@ -9,6 +9,7 @@ mod diffs;
 mod tasks;
 mod network;
 mod auth;
+mod summary;
 
 const WHO_AM_I: &str = "api/user.whoami";
 /// Preset for comfy-table so that it styles the table for no borders
@@ -41,8 +42,12 @@ fn main() {
                 .short("l")
                 .long("limit")
                 .help("limit results by a value")
-                .default_value("20"))
-        ).get_matches();
+                .default_value("20")))
+        .subcommand(SubCommand::with_name("summary")
+            .about("Gives a snapshot of what is relevant to you in the moment")
+            .version("0.1.0")
+            .author("Shaishav <shaishavgandhi05@gmail.com>"))
+        .get_matches();
 
     let result = auth::init();
     let config = match result {
@@ -55,5 +60,7 @@ fn main() {
         diffs::process_diff_command(matches, &config)
     } else if let Some(matches) = matches.subcommand_matches("tasks") {
         tasks::process_task_command(matches, &config)
+    } else if let Some(matches) = matches.subcommand_matches("summary") {
+        summary::process_summary(matches, &config);
     }
 }

src/structs.rs

@@ -22,7 +22,7 @@ pub struct WhoAmIResponse {
 pub struct UserResponse {
     pub phid: String,
     #[serde(rename = "userName")]
-    pub user_ame: String
+    pub user_name: String
 }
 
 #[derive(Deserialize, Serialize, Debug)]

src/summary.rs

@@ -0,0 +1,28 @@
+use clap::ArgMatches;
+use crate::structs::FabConfig;
+use crate::diffs::{get_needs_review_diffs, render_diffs, get_authored_diffs};
+use crate::tasks::{get_tasks, Priority, render_tasks};
+use console::style;
+
+pub fn process_summary(_matches: &ArgMatches, config: &FabConfig) {
+    let needs_review_diffs = get_needs_review_diffs(config).unwrap();
+    let authored_diffs = get_authored_diffs(config).unwrap();
+    let tasks = get_tasks("10", &[Priority::get_value_for_name("high").unwrap()], config)
+        .expect("Couldn't fetch tasks");
+
+    println!("{}", style("Diffs that need your review").bold().underlined());
+    println!();
+
+    render_diffs(config, &needs_review_diffs);
+    println!();
+
+    println!("{}", style("Your open diffs").bold().underlined());
+    println!();
+
+    render_diffs(config, &authored_diffs);
+    println!();
+
+    println!("{}", style("Tasks that need your attention").bold().underlined());
+    println!();
+    render_tasks(&tasks, config);
+}

src/tasks.rs

@@ -11,14 +11,7 @@ pub fn process_task_command(matches: &ArgMatches, config: &FabConfig) {
     process_list_tasks(matches, config)
 }
 
-fn process_list_tasks(matches: &ArgMatches, config: &FabConfig) {
-    let limit = matches.value_of("limit").expect("No limit specified for query");
-    let priorities: Vec<_> = matches.values_of("priority")
-        .expect("Couldn't parse priority. Must be one of ['unbreak-now', 'needs-triage', 'high', 'normal', 'low', 'wishlist']")
-        .collect();
-
-    let priorities: Vec<i32> = priorities.iter().map(|priority| Priority::get_value_for_name(priority).unwrap()).collect();
-
+pub fn get_tasks(limit: &str, priorities: &[i32], config: &FabConfig) -> Result<Vec<Maniphest>, String> {
     let mut map = Map::new();
     map.insert("queryKey".to_string(), Value::from("assigned"));
     map.insert("api.token".to_string(), Value::from(config.api_token.clone()));
@@ -34,15 +27,17 @@ fn process_list_tasks(matches: &ArgMatches, config: &FabConfig) {
 
     let result = auth::send::<ManiphestSearchData>(config, reqwest::blocking::Client::new()
         .post(&url)
-        .form(&json_body))
-        .expect("Error fetching tasks from Conduit");
-
+        .form(&json_body));
 
-    let tasks = result.data;
-    render_tasks(&tasks, config)
+    match result {
+        Ok(response) => {
+            Result::Ok(response.data)
+        },
+        Err(_mess) => Result::Err(String::from("Error fetching tasks"))
+    }
 }
 
-fn render_tasks(tasks: &[Maniphest], config: &FabConfig) {
+pub fn render_tasks(tasks: &[Maniphest], config: &FabConfig) {
     let mut table = Table::new();
 
     table
@@ -65,13 +60,25 @@ fn render_tasks(tasks: &[Maniphest], config: &FabConfig) {
     println!("{}", table)
 }
 
+fn process_list_tasks(matches: &ArgMatches, config: &FabConfig) {
+    let limit = matches.value_of("limit").expect("No limit specified for query");
+    let priorities: Vec<_> = matches.values_of("priority")
+        .expect("Couldn't parse priority. Must be one of ['unbreak-now', 'needs-triage', 'high', 'normal', 'low', 'wishlist']")
+        .collect();
+
+    let priorities: Vec<i32> = priorities.iter().map(|priority| Priority::get_value_for_name(priority).unwrap()).collect();
+
+    let tasks = get_tasks(limit, &priorities, config).expect("Error fetching tasks");
+    render_tasks(&tasks, config)
+}
+
 #[derive(Debug, Deserialize)]
 struct ManiphestSearchData {
     data: Vec<Maniphest>
 }
 
 #[derive(Debug, Deserialize)]
-struct Maniphest {
+pub struct Maniphest {
     id: i32,
     fields: Fields
 }
@@ -109,20 +116,20 @@ impl Maniphest {
 }
 
 #[derive(Debug, Deserialize)]
-struct Fields {
+pub struct Fields {
     name: String,
     status: Status,
     priority: Priority
 }
 
 #[derive(Debug, Deserialize)]
-struct Status {
+pub struct Status {
     name: String,
     value: String
 }
 
 #[derive(Debug, Deserialize)]
-struct Priority {
+pub struct Priority {
     value: i32,
     name: String
 }