Schedule job for initial merge

Author: Mauricio Cassola

parser/src/command/decision.rs

@@ -48,7 +48,7 @@ pub enum Reversibility {
     Irreversible,
 }
 
-#[derive(Serialize, Deserialize, Debug, Clone, ToSql, FromSql, Eq, PartialEq)]
+#[derive(Serialize, Deserialize, Debug, Clone, Copy, ToSql, FromSql, Eq, PartialEq)]
 #[postgres(name = "resolution")]
 pub enum Resolution {
     #[postgres(name = "merge")]

src/db/issue_decision_state.rs

@@ -2,7 +2,7 @@
 //! the decision process state of each issue
 
 use anyhow::{Context as _, Result};
-use chrono::{DateTime, FixedOffset};
+use chrono::{DateTime, Utc};
 use parser::command::decision::{Resolution, Reversibility};
 use serde::{Deserialize, Serialize};
 use std::collections::BTreeMap;
@@ -12,8 +12,8 @@ use tokio_postgres::Client as DbClient;
 pub struct IssueDecisionState {
     pub issue_id: i64,
     pub initiator: String,
-    pub start_date: DateTime<FixedOffset>,
-    pub end_date: DateTime<FixedOffset>,
+    pub start_date: DateTime<Utc>,
+    pub end_date: DateTime<Utc>,
     pub current: BTreeMap<String, UserStatus>,
     pub history: BTreeMap<String, Vec<UserStatus>>,
     pub reversibility: Reversibility,
@@ -32,8 +32,8 @@ pub async fn insert_issue_decision_state(
     db: &DbClient,
     issue_number: &u64,
     initiator: &String,
-    start_date: &DateTime<FixedOffset>,
-    end_date: &DateTime<FixedOffset>,
+    start_date: &DateTime<Utc>,
+    end_date: &DateTime<Utc>,
     current: &BTreeMap<String, UserStatus>,
     history: &BTreeMap<String, Vec<UserStatus>>,
     reversibility: &Reversibility,
@@ -56,7 +56,7 @@ pub async fn insert_issue_decision_state(
 pub async fn update_issue_decision_state(
     db: &DbClient,
     issue_number: &u64,
-    end_date: &DateTime<FixedOffset>,
+    end_date: &DateTime<Utc>,
     current: &BTreeMap<String, UserStatus>,
     history: &BTreeMap<String, Vec<UserStatus>>,
     reversibility: &Reversibility,
@@ -95,8 +95,8 @@ pub async fn get_issue_decision_state(
 fn deserialize_issue_decision_state(row: &tokio_postgres::row::Row) -> Result<IssueDecisionState> {
     let issue_id: i64 = row.try_get(0)?;
     let initiator: String = row.try_get(1)?;
-    let start_date: DateTime<FixedOffset> = row.try_get(2)?;
-    let end_date: DateTime<FixedOffset> = row.try_get(3)?;
+    let start_date: DateTime<Utc> = row.try_get(2)?;
+    let end_date: DateTime<Utc> = row.try_get(3)?;
     let current: BTreeMap<String, UserStatus> = serde_json::from_value(row.try_get(4).unwrap())?;
     let history: BTreeMap<String, Vec<UserStatus>> =
         serde_json::from_value(row.try_get(5).unwrap())?;

src/github.rs

@@ -402,7 +402,7 @@ impl fmt::Display for IssueRepository {
 }
 
 impl IssueRepository {
-    fn url(&self) -> String {
+    pub fn url(&self) -> String {
         format!(
             "https://api.github.com/repos/{}/{}",
             self.organization, self.repository
@@ -779,6 +779,27 @@ impl Issue {
         Ok(())
     }
 
+    pub async fn merge(&self, client: &GithubClient) -> anyhow::Result<()> {
+        let merge_url = format!("{}/pulls/{}/merge", self.repository().url(), self.number);
+
+        // change defaults by reading from somewhere, maybe in .toml?
+        #[derive(serde::Serialize)]
+        struct MergeIssue<'a> {
+            commit_title: &'a str,
+            merge_method: &'a str
+        }
+
+        client
+            ._send_req(client.put(&merge_url).json(&MergeIssue {
+                commit_title: "Merged by the bot!",
+                merge_method: "merge"
+            }))
+            .await
+            .context("failed to merge issue")?;
+
+        Ok(())
+    }
+
     /// Returns the diff in this event, for Open and Synchronize events for now.
     pub async fn diff(&self, client: &GithubClient) -> anyhow::Result<Option<String>> {
         let (before, after) = if let (Some(base), Some(head)) = (&self.base, &self.head) {
@@ -1827,7 +1848,7 @@ impl GithubClient {
         response.text().await.context("raw gist from url")
     }
 
-    fn get(&self, url: &str) -> RequestBuilder {
+    pub fn get(&self, url: &str) -> RequestBuilder {
         log::trace!("get {:?}", url);
         self.client.get(url).configure(self)
     }

src/handlers/decision.rs

@@ -1,23 +1,35 @@
+use crate::db::jobs::*;
 use crate::{
     config::DecisionConfig, db::issue_decision_state::*, github::Event, handlers::Context,
     interactions::ErrorComment,
 };
 use anyhow::Context as Ctx;
-use chrono::{DateTime, Duration, FixedOffset};
-use parser::command::decision::{DecisionCommand, Resolution::*, Reversibility::*};
+use chrono::{DateTime, Duration, Utc};
+use parser::command::decision::Resolution::{Hold, Merge};
+use parser::command::decision::*;
+use serde::{Deserialize, Serialize};
 use std::collections::BTreeMap;
 
 // get state for issue_id from db
-// if no state (first call)
-    // initialize state
-    // schedule job if necessary
-    // send comment to github
-    // save state
-// if state
-    // apply logic to decide what to do
-    // schedule job if necessary
-    // send comment to github
-    // save state
+    // if no state (first call)
+        // initialize state
+        // schedule job if necessary
+        // send comment to github
+        // save state
+    // if state
+        // apply logic to decide what to do
+        // schedule job if necessary
+        // send comment to github
+        // save state
+
+pub const DECISION_PROCESS_JOB_NAME: &str = "decision_process_action";
+
+#[derive(Serialize, Deserialize)]
+pub struct DecisionProcessActionMetadata {
+    pub message: String,
+    pub get_issue_url: String,
+    pub status: Resolution,
+}
 
 pub(super) async fn handle_command(
     ctx: &Context,
@@ -77,8 +89,8 @@ pub(super) async fn handle_command(
             match resolution {
                 Hold => Ok(()), // change me!
                 Merge => {
-                    let start_date: DateTime<FixedOffset> = chrono::Utc::now().into();
-                    let end_date: DateTime<FixedOffset> =
+                    let start_date: DateTime<Utc> = chrono::Utc::now().into();
+                    let end_date: DateTime<Utc> =
                         start_date.checked_add_signed(Duration::days(10)).unwrap();
 
                     let mut current: BTreeMap<String, UserStatus> = BTreeMap::new();
@@ -87,7 +99,7 @@ pub(super) async fn handle_command(
                         UserStatus {
                             comment_id: "comment_id".to_string(),
                             text: "something".to_string(),
-                            reversibility: Reversible,
+                            reversibility: Reversibility::Reversible,
                             resolution: Merge,
                         },
                     );
@@ -106,6 +118,21 @@ pub(super) async fn handle_command(
                     )
                     .await?;
 
+                    let metadata = serde_json::value::to_value(DecisionProcessActionMetadata {
+                        message: "some message".to_string(),
+                        get_issue_url: format!("{}/issues/{}", issue.repository().url(), issue.number),
+                        status: Merge,
+                    })
+                    .unwrap();
+
+                    insert_job(
+                        &db,
+                        &DECISION_PROCESS_JOB_NAME.to_string(),
+                        &end_date,
+                        &metadata,
+                    )
+                    .await?;
+
                     // let team = github::get_team(&ctx.github, &"T-lang"); // change this to be configurable in toml?
 
                     let comment = format!(

src/handlers/jobs.rs

@@ -3,8 +3,12 @@
 // the job name and the corresponding function.
 
 // Further info could be find in src/jobs.rs
-
 use super::Context;
+use crate::github::*;
+use crate::handlers::decision::{DecisionProcessActionMetadata, DECISION_PROCESS_JOB_NAME};
+use parser::command::decision::Resolution::Merge;
+use reqwest::Client;
+use tracing as log;
 
 pub async fn handle_job(
     ctx: &Context,
@@ -17,6 +21,9 @@ pub async fn handle_job(
             super::rustc_commits::synchronize_commits_inner(ctx, None).await;
             Ok(())
         }
+        matched_name if *matched_name == DECISION_PROCESS_JOB_NAME.to_string() => {
+            decision_process_handler(&metadata).await
+        }
         _ => default(&name, &metadata),
     }
 }
@@ -30,3 +37,28 @@ fn default(name: &String, metadata: &serde_json::Value) -> anyhow::Result<()> {
 
     Ok(())
 }
+
+async fn decision_process_handler(metadata: &serde_json::Value) -> anyhow::Result<()> {
+    tracing::trace!(
+        "handle_job fell into decision process case: (metadata={:?})",
+        metadata
+    );
+
+    let metadata: DecisionProcessActionMetadata = serde_json::from_value(metadata.clone())?;
+
+    match metadata.status {
+        Merge => {
+            let gh_client = GithubClient::new_with_default_token(Client::new().clone());
+
+            let request = gh_client.get(&metadata.get_issue_url);
+
+            match gh_client.json::<Issue>(request).await {
+                Ok(issue) => issue.merge(&gh_client).await?,
+                Err(e) => log::error!("Failed to get issue {}, error: {}", metadata.get_issue_url, e),
+            }
+        }
+        _ => {}
+    }
+
+    Ok(())
+}