tasks: add task.completed_at

tasks/Cargo.toml

@@ -8,6 +8,7 @@ edition = "2018"
 
 [dependencies]
 anyhow = "1.0.43"
+chrono = "0.4.19"
 dirs = "3.0.2"
 serde = { version = "1.0", features = ["derive"] }
 serde_json = "1.0.64"

tasks/src/driver/task_json_repository.rs

@@ -10,15 +10,15 @@ struct Tasks {
 
 #[derive(Clone, Debug, serde::Deserialize, serde::Serialize)]
 struct TaskData {
-    pub done: bool,
+    pub completed_at: Option<i64>,
     pub id: usize,
     pub text: String,
 }
 
 impl From<Task> for TaskData {
     fn from(task: Task) -> Self {
         Self {
-            done: task.done(),
+            completed_at: task.completed_at(),
             id: task.id(),
             text: task.text().to_string(),
         }
@@ -28,7 +28,7 @@ impl From<Task> for TaskData {
 // -> TryFrom
 impl From<TaskData> for Task {
     fn from(data: TaskData) -> Self {
-        Self::raw(data.id, data.text, data.done)
+        Self::raw(data.id, data.text, data.completed_at)
     }
 }
 
@@ -74,7 +74,7 @@ impl TaskRepository for TaskJsonRepository {
         tasks.tasks.push(TaskData {
             id: tasks.next_id,
             text,
-            done: false,
+            completed_at: None,
         });
         tasks.next_id += 1;
         self.write(&tasks);
@@ -105,8 +105,8 @@ impl TaskRepository for TaskJsonRepository {
     fn save(&self, task: Task) {
         let mut tasks = self.read();
         let task_position = tasks.tasks.iter().position(|t| t.id == task.id()).unwrap();
-        let task = tasks.tasks.get_mut(task_position).unwrap();
-        task.done = true;
+        let task_data_mut = tasks.tasks.get_mut(task_position).unwrap();
+        *task_data_mut = TaskData::from(task);
         self.write(&tasks);
     }
 }
@@ -132,17 +132,20 @@ mod tests {
         assert_eq!(repository.find_by_id(1), Some(Task::new(1, "task1")));
         assert_eq!(
             fs::read_to_string(tasks_json.as_path())?,
-            r#"{"next_id":2,"tasks":[{"done":false,"id":1,"text":"task1"}]}"#
+            r#"{"next_id":2,"tasks":[{"completed_at":null,"id":1,"text":"task1"}]}"#
         );
 
         let mut task = Task::new(1, "task1");
         task.complete();
         repository.save(task.clone());
         assert_eq!(repository.find_all(), vec![task.clone()]);
-        assert_eq!(repository.find_by_id(1), Some(task));
+        assert_eq!(repository.find_by_id(1), Some(task.clone()));
         assert_eq!(
             fs::read_to_string(tasks_json.as_path())?,
-            r#"{"next_id":2,"tasks":[{"done":true,"id":1,"text":"task1"}]}"#
+            format!(
+                r#"{{"next_id":2,"tasks":[{{"completed_at":{},"id":1,"text":"task1"}}]}}"#,
+                task.completed_at().unwrap()
+            )
         );
 
         repository.delete(1);

tasks/src/entity/task.rs

@@ -1,33 +1,43 @@
+use chrono::Utc;
+
 #[derive(Clone, Debug, Eq, PartialEq)]
 pub struct Task {
-    done: bool,
+    completed_at: Option<i64>,
     id: usize,
     text: String,
 }
 
 impl Task {
-    pub fn raw(id: usize, text: String, done: bool) -> Self {
-        Self { done, id, text }
+    pub fn raw(id: usize, text: String, completed_at: Option<i64>) -> Self {
+        Self {
+            completed_at,
+            id,
+            text,
+        }
     }
 
     pub fn new(id: usize, text: impl Into<String>) -> Self {
         Self {
-            done: false,
+            completed_at: None,
             id,
             text: text.into(),
         }
     }
 
     pub fn done(&self) -> bool {
-        self.done
+        self.completed_at.is_some()
     }
 
     pub fn id(&self) -> usize {
         self.id
     }
 
     pub fn complete(&mut self) {
-        self.done = true;
+        self.completed_at = Some(Utc::now().timestamp());
+    }
+
+    pub fn completed_at(&self) -> Option<i64> {
+        self.completed_at
     }
 
     pub fn text(&self) -> &str {
@@ -42,9 +52,12 @@ mod tests {
     #[test]
     fn test() {
         let mut task = Task::new(1, "task1");
-        assert_eq!(task, Task::raw(1, "task1".to_string(), false));
+        assert_eq!(task, Task::raw(1, "task1".to_string(), None));
         assert_eq!(task.id(), 1);
         task.complete();
-        assert_eq!(task, Task::raw(1, "task1".to_string(), true));
+        assert_eq!(
+            task,
+            Task::raw(1, "task1".to_string(), Some(task.completed_at().unwrap()))
+        );
     }
 }

tasks/src/main.rs

@@ -31,12 +31,10 @@ fn main() -> anyhow::Result<()> {
     let list_presenter = Rc::new(ListConsolePresenter::new());
     let repository = Rc::new(TaskJsonRepository::new()?);
     match opt.subcommand {
-        Subcommand::Add { text } => AddUseCase::new(repository.clone()).handle(text),
-        Subcommand::Complete { id } => CompleteUseCase::new(repository.clone()).handle(id),
-        Subcommand::List { all } => {
-            ListUseCase::new(list_presenter.clone(), repository.clone()).handle(all)
-        }
-        Subcommand::Remove { id } => RemoveUseCase::new(repository.clone()).handle(id),
+        Subcommand::Add { text } => AddUseCase::new(repository).handle(text),
+        Subcommand::Complete { id } => CompleteUseCase::new(repository).handle(id),
+        Subcommand::List { all } => ListUseCase::new(list_presenter, repository).handle(all),
+        Subcommand::Remove { id } => RemoveUseCase::new(repository).handle(id),
     }
     Ok(())
 }