bin/tau: fix a minor bug updating rank and desc, and event log now shows every change

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

@@ -140,10 +140,18 @@ pub fn comments_as_string(comments: Vec<Comment>) -> String {
 pub fn events_as_string(events: Vec<TaskEvent>) -> (String, String) {
     let mut events_str = String::new();
     let mut timestamps_str = String::new();
-    let long_comment_width = 50;
+    let width = 50;
     for event in events {
         writeln!(timestamps_str, "{}", event.timestamp).unwrap();
         match event.action.as_str() {
+            "title" => {
+                writeln!(events_str, "- {} changed title to {}", event.author, event.content)
+                    .unwrap();
+            }
+            "rank" => {
+                writeln!(events_str, "- {} changed rank to {}", event.author, event.content)
+                    .unwrap();
+            }
             "state" => {
                 writeln!(events_str, "- {} changed state to {}", event.author, event.content)
                     .unwrap();
@@ -151,18 +159,40 @@ pub fn events_as_string(events: Vec<TaskEvent>) -> (String, String) {
             "assign" => {
                 writeln!(events_str, "- {} assigned {}", event.author, event.content).unwrap();
             }
+            "project" => {
+                writeln!(events_str, "- {} changed project to {}", event.author, event.content)
+                    .unwrap();
+            }
+            "due" => {
+                writeln!(
+                    events_str,
+                    "- {} changed due date to {}",
+                    event.author,
+                    timestamp_to_date(event.content.parse::<i64>().unwrap_or(0), DateFormat::Date)
+                )
+                .unwrap();
+            }
             "comment" => {
                 // wrap long comments
-                let ev_content = fill(
-                    &event.content,
-                    textwrap::Options::new(long_comment_width).subsequent_indent("  "),
-                );
+                let ev_content =
+                    fill(&event.content, textwrap::Options::new(width).subsequent_indent("  "));
                 // skip wrapped lines to align timestamp with the first line
                 for _ in 1..ev_content.lines().collect::<Vec<&str>>().len() {
                     writeln!(timestamps_str, " ").unwrap();
                 }
                 writeln!(events_str, "- {} made a comment: {}", event.author, ev_content).unwrap();
             }
+            "desc" => {
+                // wrap long description
+                let ev_content =
+                    fill(&event.content, textwrap::Options::new(width).subsequent_indent("  "));
+                // skip wrapped lines to align timestamp with the first line
+                for _ in 1..ev_content.lines().collect::<Vec<&str>>().len() {
+                    writeln!(timestamps_str, " ").unwrap();
+                }
+                writeln!(events_str, "- {} changed description to: {}", event.author, ev_content)
+                    .unwrap();
+            }
             _ => {}
         }
     }

bin/tau/taud/src/jsonrpc.rs

@@ -132,7 +132,7 @@ impl JsonRpcInterface {
             &self.dataset_path,
         )?;
         new_task.set_project(&task.project);
-        new_task.set_assign(&task.assign, &self.nickname);
+        new_task.set_assign(&task.assign);
 
         self.notify_queue_sender.send(new_task).await.map_err(Error::from)?;
         Ok(json!(true))
@@ -187,7 +187,8 @@ impl JsonRpcInterface {
         let mut task: TaskInfo = self.load_task_by_id(&params[0], ws)?;
 
         if states.contains(&state.as_str()) {
-            task.set_state(&state, &self.nickname);
+            task.set_state(&state);
+            task.set_event("state", &self.nickname, &state);
         }
 
         self.notify_queue_sender.send(task).await.map_err(Error::from)?;
@@ -211,6 +212,7 @@ impl JsonRpcInterface {
 
         let mut task: TaskInfo = self.load_task_by_id(&params[0], ws)?;
         task.set_comment(Comment::new(&comment_content, &self.nickname));
+        task.set_event("comment", &self.nickname, &comment_content);
 
         self.notify_queue_sender.send(task).await.map_err(Error::from)?;
 
@@ -375,14 +377,19 @@ impl JsonRpcInterface {
             let title: String = serde_json::from_value(title)?;
             if !title.is_empty() {
                 task.set_title(&title);
+                task.set_event("title", &self.nickname, &title);
             }
         }
 
         if fields.contains_key("desc") {
-            let description = fields.get("description");
+            let description = fields.get("desc");
             if let Some(description) = description {
-                let description: String = serde_json::from_value(description.clone())?;
-                task.set_desc(&description);
+                let description: Option<String> = serde_json::from_value(description.clone())?;
+                if description.is_some() {
+                    let desc = description.unwrap();
+                    task.set_desc(&desc);
+                    task.set_event("desc", &self.nickname, &desc);
+                }
             }
         }
 
@@ -390,7 +397,10 @@ impl JsonRpcInterface {
             let rank_opt = fields.get("rank");
             if let Some(rank) = rank_opt {
                 let rank: Option<f32> = serde_json::from_value(rank.clone())?;
-                task.set_rank(rank);
+                if rank.is_some() {
+                    task.set_rank(rank);
+                    task.set_event("rank", &self.nickname, &rank.unwrap().to_string());
+                }
             }
         }
 
@@ -399,6 +409,9 @@ impl JsonRpcInterface {
             let due: Option<Option<Timestamp>> = serde_json::from_value(due)?;
             if let Some(d) = due {
                 task.set_due(d);
+                if d.is_some() {
+                    task.set_event("due", &self.nickname, &d.unwrap().0.to_string());
+                }
             }
         }
 
@@ -406,7 +419,8 @@ impl JsonRpcInterface {
             let assign = fields.get("assign").unwrap().clone();
             let assign: Vec<String> = serde_json::from_value(assign)?;
             if !assign.is_empty() {
-                task.set_assign(&assign, &self.nickname);
+                task.set_assign(&assign);
+                task.set_event("assign", &self.nickname, &assign.join(", "));
             }
         }
 
@@ -415,6 +429,7 @@ impl JsonRpcInterface {
             let project: Vec<String> = serde_json::from_value(project)?;
             if !project.is_empty() {
                 task.set_project(&project);
+                task.set_event("project", &self.nickname, &project.join(", "));
             }
         }
 

bin/tau/taud/src/task_info.rs

@@ -183,10 +183,9 @@ impl TaskInfo {
         self.desc = desc.into();
     }
 
-    pub fn set_assign(&mut self, assign: &[String], owner: &str) {
+    pub fn set_assign(&mut self, assign: &[String]) {
         debug!(target: "tau", "TaskInfo::set_assign()");
         self.assign = TaskAssigns(assign.to_owned());
-        self.set_event("assign", owner, &assign.join(", "));
     }
 
     pub fn set_project(&mut self, project: &[String]) {
@@ -197,7 +196,6 @@ impl TaskInfo {
     pub fn set_comment(&mut self, c: Comment) {
         debug!(target: "tau", "TaskInfo::set_comment()");
         self.comments.0.push(c.clone());
-        self.set_event("comment", &c.author, &c.content);
     }
 
     pub fn set_rank(&mut self, r: Option<f32>) {
@@ -217,13 +215,12 @@ impl TaskInfo {
         }
     }
 
-    pub fn set_state(&mut self, state: &str, owner: &str) {
+    pub fn set_state(&mut self, state: &str) {
         debug!(target: "tau", "TaskInfo::set_state()");
         if self.get_state() == state {
             return
         }
         self.state = state.to_string();
-        self.set_event("state", owner, state);
     }
 }