bin/tau: add assign change and comments to a task events list

bin/tau/tau-cli/src/drawdown.rs

@@ -15,10 +15,7 @@ pub fn drawdown(date: String, tasks: Vec<TaskInfo>, owner: String) -> Result<()>
         let stopped_tasks = tasks
             .clone()
             .into_iter()
-            .filter(|t| {
-                t.events.last().unwrap_or(&TaskEvent::default()).action.clone() == "stop" &&
-                    t.owner == owner
-            })
+            .filter(|t| t.state == "stop" && t.owner == owner)
             .collect::<Vec<TaskInfo>>();
         ret.insert(owner, stopped_tasks);
     }
@@ -62,6 +59,7 @@ pub fn drawdown(date: String, tasks: Vec<TaskInfo>, owner: String) -> Result<()>
             let date_tasks: Vec<TaskInfo> = owner_stopped_tasks
                 .into_iter()
                 .filter(|t| {
+                    // last event is always state stop
                     let event_date = NaiveDateTime::from_timestamp(
                         t.events.last().unwrap_or(&TaskEvent::default()).timestamp.0,
                         0,

bin/tau/tau-cli/src/filter.rs

@@ -1,22 +1,13 @@
 use chrono::{Datelike, NaiveDateTime, Utc};
 use serde_json::Value;
 
-use crate::{
-    primitives::{State, TaskInfo},
-    TaskEvent,
-};
-
-/// Helper function to check task's state
-fn check_task_state(task: &TaskInfo, state: State) -> bool {
-    let last_state = task.events.last().unwrap_or(&TaskEvent::default()).action.clone();
-    state.to_string() == last_state
-}
+use crate::primitives::{State, TaskInfo};
 
 pub fn apply_filter(tasks: &mut Vec<TaskInfo>, filter: &str) {
     match filter {
-        "open" => tasks.retain(|task| check_task_state(task, State::Open)),
-        "start" => tasks.retain(|task| check_task_state(task, State::Start)),
-        "pause" => tasks.retain(|task| check_task_state(task, State::Pause)),
+        "open" => tasks.retain(|task| task.state == State::Open.to_string()),
+        "start" => tasks.retain(|task| task.state == State::Start.to_string()),
+        "pause" => tasks.retain(|task| task.state == State::Pause.to_string()),
 
         _ if filter.len() == 4 && filter.parse::<u32>().is_ok() => {
             let (month, year) =

bin/tau/tau-cli/src/main.rs

@@ -140,7 +140,7 @@ async fn main() -> Result<()> {
                 }
                 None => {
                     let task = tau.get_task_by_id(task_id).await?;
-                    let state = &task.events.last().unwrap_or(&TaskEvent::default()).action.clone();
+                    let state = State::from_str(&task.state)?;
                     println!("Task {}: {}", task_id, state);
                     Ok(())
                 }

bin/tau/tau-cli/src/primitives.rs

@@ -69,6 +69,7 @@ pub struct TaskInfo {
     pub due: Option<i64>,
     pub rank: f32,
     pub created_at: i64,
+    pub state: String,
     pub events: Vec<TaskEvent>,
     pub comments: Vec<Comment>,
 }
@@ -76,6 +77,7 @@ pub struct TaskInfo {
 #[derive(Clone, serde::Serialize, serde::Deserialize, Debug)]
 pub struct TaskEvent {
     pub action: String,
+    pub content: String,
     pub timestamp: Timestamp,
 }
 
@@ -87,7 +89,11 @@ impl std::fmt::Display for TaskEvent {
 
 impl Default for TaskEvent {
     fn default() -> Self {
-        Self { action: State::Open.to_string(), timestamp: Timestamp::current_time() }
+        Self {
+            action: State::Open.to_string(),
+            content: "".to_string(),
+            timestamp: Timestamp::current_time(),
+        }
     }
 }
 

bin/tau/tau-cli/src/view.rs

@@ -53,8 +53,7 @@ pub fn print_task_list(tasks: Vec<TaskInfo>, filters: Vec<String>) -> Result<()>
     };
 
     for task in tasks {
-        let state = task.events.last().unwrap_or(&TaskEvent::default()).action.clone();
-        let state = State::from_str(&state)?;
+        let state = State::from_str(&task.state.clone())?;
 
         let (max_style, min_style, mid_style, gen_style) = if state.is_start() {
             ("bFg", "Fc", "Fg", "Fg")
@@ -97,7 +96,6 @@ pub fn print_task_list(tasks: Vec<TaskInfo>, filters: Vec<String>) -> Result<()>
 }
 
 pub fn print_task_info(taskinfo: TaskInfo) -> Result<()> {
-    let current_state = &taskinfo.events.last().unwrap_or(&TaskEvent::default()).action.clone();
     let due = timestamp_to_date(taskinfo.due.unwrap_or(0), DateFormat::Date);
     let created_at = timestamp_to_date(taskinfo.created_at, DateFormat::DateTime);
 
@@ -113,7 +111,7 @@ pub fn print_task_info(taskinfo: TaskInfo) -> Result<()> {
         [Bd =>"due", due],
         ["rank", &taskinfo.rank.to_string()],
         [Bd =>"created_at", created_at],
-        ["current_state", current_state]);
+        ["current_state", &taskinfo.state]);
 
     table.set_format(
         FormatBuilder::new()
@@ -144,7 +142,21 @@ pub fn comments_as_string(comments: Vec<Comment>) -> String {
 pub fn events_as_string(events: Vec<TaskEvent>) -> String {
     let mut events_str = String::new();
     for event in events {
-        writeln!(events_str, "State changed to {} at {}", event.action, event.timestamp).unwrap();
+        match event.action.as_str() {
+            "state" => {
+                writeln!(events_str, "State changed to {} at {}", event.content, event.timestamp)
+                    .unwrap()
+            }
+            "assign" => {
+                writeln!(events_str, "Assigned to {} at {}", event.content, event.timestamp)
+                    .unwrap();
+            }
+            "comment" => {
+                writeln!(events_str, "{} added a comment at {}", event.content, event.timestamp)
+                    .unwrap();
+            }
+            _ => {}
+        }
     }
     events_str
 }

bin/tau/taud/src/jsonrpc.rs

@@ -284,8 +284,6 @@ impl JsonRpcInterface {
 
         for task in tasks {
             task.save(&path)?;
-            // save_json_file::<TaskInfo>(&TaskInfo::get_path(&task.ref_id, &path), &task)
-            //     .map_err(TaudError::Darkfi)?;
         }
 
         Ok(json!(true))

bin/tau/taud/src/task_info.rs

@@ -22,12 +22,13 @@ use crate::{
 #[derive(Clone, Debug, Serialize, Deserialize, SerialEncodable, SerialDecodable, PartialEq, Eq)]
 struct TaskEvent {
     action: String,
+    content: String,
     timestamp: Timestamp,
 }
 
 impl TaskEvent {
-    fn new(action: String) -> Self {
-        Self { action, timestamp: Timestamp::current_time() }
+    fn new(action: String, content: String) -> Self {
+        Self { action, content, timestamp: Timestamp::current_time() }
     }
 }
 
@@ -70,6 +71,7 @@ pub struct TaskInfo {
     due: Option<Timestamp>,
     rank: f32,
     created_at: Timestamp,
+    state: String,
     events: TaskEvents,
     comments: TaskComments,
 }
@@ -115,6 +117,7 @@ impl TaskInfo {
             due,
             rank,
             created_at,
+            state: "open".into(),
             comments: TaskComments(vec![]),
             events: TaskEvents(vec![]),
         })
@@ -156,11 +159,7 @@ impl TaskInfo {
 
     pub fn get_state(&self) -> String {
         debug!(target: "tau", "TaskInfo::get_state()");
-        if let Some(ev) = self.events.0.last() {
-            ev.action.clone()
-        } else {
-            "open".into()
-        }
+        self.state.clone()
     }
 
     pub fn get_path(ref_id: &str, dataset_path: &Path) -> PathBuf {
@@ -186,6 +185,7 @@ impl TaskInfo {
     pub fn set_assign(&mut self, assign: &[String]) {
         debug!(target: "tau", "TaskInfo::set_assign()");
         self.assign = TaskAssigns(assign.to_owned());
+        self.set_event("assign", &assign.join(", "));
     }
 
     pub fn set_project(&mut self, project: &[String]) {
@@ -195,7 +195,8 @@ impl TaskInfo {
 
     pub fn set_comment(&mut self, c: Comment) {
         debug!(target: "tau", "TaskInfo::set_comment()");
-        self.comments.0.push(c);
+        self.comments.0.push(c.clone());
+        self.set_event("comment", &c.author);
     }
 
     pub fn set_rank(&mut self, r: f32) {
@@ -208,12 +209,20 @@ impl TaskInfo {
         self.due = d;
     }
 
-    pub fn set_state(&mut self, action: &str) {
+    pub fn set_event(&mut self, action: &str, content: &str) {
+        debug!(target: "tau", "TaskInfo::set_event()");
+        if !content.is_empty() {
+            self.events.0.push(TaskEvent::new(action.into(), content.into()));
+        }
+    }
+
+    pub fn set_state(&mut self, state: &str) {
         debug!(target: "tau", "TaskInfo::set_state()");
-        if self.get_state() == action {
+        if self.get_state() == state {
             return
         }
-        self.events.0.push(TaskEvent::new(action.into()));
+        self.state = state.to_string();
+        self.set_event("state", state);
     }
 }