Add db support for issue_decision_state

Author: Mauricio Cassola

parser/src/command/decision.rs

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

src/db.rs

@@ -8,7 +8,7 @@ use std::sync::{Arc, Mutex};
 use tokio::sync::{OwnedSemaphorePermit, Semaphore};
 use tokio_postgres::Client as DbClient;
 
-pub mod decision_state;
+pub mod issue_decision_state;
 pub mod issue_data;
 pub mod jobs;
 pub mod notifications;
@@ -280,14 +280,13 @@ CREATE TYPE reversibility AS ENUM ('reversible', 'irreversible');
     "
 CREATE TYPE resolution AS ENUM ('hold', 'merge');
 ",
-    "CREATE TABLE decision_state (
+"CREATE TABLE issue_decision_state (
     issue_id BIGINT PRIMARY KEY,
     initiator TEXT NOT NULL,
-    team_members JSONB NOT NULL,
     start_date TIMESTAMP WITH TIME ZONE NOT NULL,
-    period_end_date TIMESTAMP WITH TIME ZONE NOT NULL,
-    current_statuses JSONB NOT NULL,
-    status_history JSONB,
+    end_date TIMESTAMP WITH TIME ZONE NOT NULL,
+    current JSONB NOT NULL,
+    history JSONB,
     reversibility reversibility NOT NULL DEFAULT 'reversible',
     resolution resolution NOT NULL DEFAULT 'merge'
 );",

src/db/decision_state.rs

@@ -0,0 +1,112 @@
+//! The issue decision state table provides a way to store 
+//! the decision process state of each issue
+
+use serde::{Deserialize, Serialize};
+use chrono::{DateTime, FixedOffset};
+use std::collections::BTreeMap;
+use parser::command::decision::{Resolution, Reversibility};
+use anyhow::{Context as _, Result};
+use tokio_postgres::Client as DbClient;
+
+#[derive(Debug, Serialize, Deserialize)]
+pub struct IssueDecisionState {
+    pub issue_id: i64,
+    pub initiator: String,
+    pub start_date: DateTime<FixedOffset>,
+    pub end_date: DateTime<FixedOffset>,
+    pub current: BTreeMap<String, UserStatus>,
+    pub history: BTreeMap<String, Vec<UserStatus>>,
+    pub reversibility: Reversibility,
+    pub resolution: Resolution,
+}
+
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+pub struct UserStatus {
+    pub comment_id: String,
+    pub text: String,
+    pub reversibility: Reversibility,
+    pub resolution: Resolution,
+}
+
+pub async fn insert_issue_decision_state(
+    db: &DbClient,
+    issue_number: &u64,
+    initiator: &String,
+    start_date: &DateTime<FixedOffset>,
+    end_date: &DateTime<FixedOffset>,
+    current: &BTreeMap<String, UserStatus>,
+    history: &BTreeMap<String, Vec<UserStatus>>,
+    reversibility: &Reversibility,
+    resolution: &Resolution,
+) -> Result<()> {
+    tracing::trace!("insert_issue_decision_state(issue_id={})", issue_number);
+    let issue_id = *issue_number as i64;
+
+    db.execute(
+        "INSERT INTO issue_decision_state (issue_id, initiator, start_date, end_date, current, history, reversibility, resolution) VALUES ($1, $2, $3, $4, $5, $6, $7, $8) 
+            ON CONFLICT DO NOTHING",
+        &[&issue_id, &initiator, &start_date, &end_date, &serde_json::to_value(current).unwrap(), &serde_json::to_value(history).unwrap(), &reversibility, &resolution],
+    )
+    .await
+    .context("Inserting decision state")?;
+
+    Ok(())
+}
+
+pub async fn update_issue_decision_state(
+    db: &DbClient, 
+    issue_number: &u64,
+    end_date: &DateTime<FixedOffset>,
+    current: &BTreeMap<String, UserStatus>,
+    history: &BTreeMap<String, Vec<UserStatus>>,
+    reversibility: &Reversibility,
+    resolution: &Resolution
+) -> Result<()> {
+    tracing::trace!("update_issue_decision_state(issue_id={})", issue_number);
+    let issue_id = *issue_number as i64;
+
+    db.execute("UPDATE issue_decision_state SET end_date = $2, current = $3, history = $4, reversibility = $5, resolution = $6 WHERE issue_id = $1", 
+        &[&issue_id, &end_date, &serde_json::to_value(current).unwrap(), &serde_json::to_value(history).unwrap(), &reversibility, &resolution]
+    )
+    .await
+    .context("Updating decision state")?;
+
+    Ok(())
+}
+
+pub async fn get_issue_decision_state(db: &DbClient, issue_number: &u64) -> Result<IssueDecisionState> {
+    tracing::trace!("get_issue_decision_state(issue_id={})", issue_number);
+    let issue_id = *issue_number as i64;
+
+    let state = db
+        .query_one(
+            "SELECT * FROM issue_decision_state WHERE issue_id = $1",
+            &[&issue_id]
+        )
+        .await
+        .context("Getting decision state data")?;
+    
+    deserialize_issue_decision_state(&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 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())?;
+    let reversibility: Reversibility = row.try_get(6)?;
+    let resolution: Resolution = row.try_get(7)?;
+
+    Ok(IssueDecisionState {
+        issue_id,
+        initiator,
+        start_date,
+        end_date,
+        current,
+        history,
+        reversibility,
+        resolution,
+    })
+}

src/db/issue_decision_state.rs

@@ -1,14 +1,15 @@
 use anyhow::Context as Ctx;
-use parser::command::decision::{DecisionCommand, ParseError};
 use crate::{
     config::DecisionConfig,
-    github::{self, Event},
+    github::{Event},
     handlers::Context,
     interactions::ErrorComment,
-    db::decision_state::*
+    db::issue_decision_state::*
 };
-use std::collections::HashMap;
-use chrono::{DateTime, Duration, Utc};
+use chrono::{DateTime, Duration, FixedOffset};
+use parser::command::decision::{DecisionCommand, Resolution::*, Reversibility::*};
+use std::collections::BTreeMap;
+use chrono::{DateTime, FixedOffset, Duration};
 
 // get state for issue_id from db
 // if no state (first call)
@@ -28,15 +29,18 @@ pub(super) async fn handle_command(
     event: &Event,
     cmd: DecisionCommand,
 ) -> anyhow::Result<()> {
+    let db = ctx.db.get().await;
+
     let DecisionCommand {
         resolution,
         reversibility
     } = cmd;
 
     let issue = event.issue().unwrap();
+    let user = event.user();
 
-    let is_team_member = event
-        .user()
+    let is_team_member = 
+        user
         .is_team_member(&ctx.github)
         .await
         .unwrap_or(false);
@@ -47,8 +51,8 @@ pub(super) async fn handle_command(
         return Ok(());
     }
 
-    match get_decision_state(issue.id) {
-        Some(state) => {
+    match get_issue_decision_state(&db, &issue.number).await {
+        Ok(_state) => {
             // let name = match disposition {
             //     Hold => "hold".into(),
             //     Custom(name) => name,
@@ -72,45 +76,49 @@ pub(super) async fn handle_command(
             //     status_history,
             //     ..state
             // })
-            Ok();
+            Ok(())
         },
-        None => {
+        _ => {
             match resolution {
-                Hold => Err(ParseError::InvalidFirstCommand),
+                Hold => Ok(()), // change me!
                 Merge => {
-                    let start_date = chrono::Utc::now().into();
-                    let end_date = start_date.checked_add_signed(Duration::days(10)).unwrap();
-
-                    let current_statuses = HashMap::new();
-                    let status_history = HashMap::new();
+                    let start_date: DateTime<FixedOffset> = chrono::Utc::now().into();
+                    let end_date: DateTime<FixedOffset> = start_date.checked_add_signed(Duration::days(10)).unwrap();
 
-                    let team = github::get_team(&ctx.github, &"T-lang"); // change this to be configurable in toml?
+                    let mut current: BTreeMap<String, UserStatus> = BTreeMap::new();
+                    current.insert("mcass19".to_string(), UserStatus{
+                        comment_id: "comment_id".to_string(),
+                        text: "something".to_string(),
+                        reversibility: Reversible,
+                        resolution: Merge,
+                    });
+                    let history: BTreeMap<String, Vec<UserStatus>> = BTreeMap::new();
 
-                    insert_decision_state(
-                        db,
-                        issue.id,
-                        user.login,
-                        start_date,
-                        end_date,
-                        current_statuses,
-                        status_history,
-                        reversibility,
-                        resolution,
-                    );
+                    insert_issue_decision_state(
+                        &db,
+                        &issue.number,
+                        &user.login,
+                        &start_date,
+                        &end_date,
+                        &current,
+                        &history,
+                        &reversibility,
+                        &Merge,
+                    ).await?;
 
-                    let comment = format!(
-                        "Wow, it looks like you want to merge this, {}.", event.user().login
-                    );
+                    // let team = github::get_team(&ctx.github, &"T-lang"); // change this to be configurable in toml?
 
                     let comment = format!(
-                        "| Team member | State |\n|-------------|-------|\n| julmontesdeoca | merge |\n| mcass19 |  |");
+                        "Wow, it looks like you want to merge this, {}.\n| Team member | State |\n|-------------|-------|\n| julmontesdeoca | merge |\n| mcass19 |  |",
+                        user.login
+                    );
 
                     issue
                         .post_comment(&ctx.github, &comment)
                         .await
                         .context("merge vote comment")?;
 
-                    Ok();
+                    Ok(())
                 }
             }
         }