Retrieve "bin/tau: remove month date dependency from tasks and orgnize them in pending and completed tasks"

bin/tau/taud/src/jsonrpc.rs

@@ -16,8 +16,8 @@ use darkfi::{
 
 use crate::{
     error::{to_json_result, TaudError, TaudResult},
+    month_tasks::MonthTasks,
     task_info::{Comment, TaskInfo},
-    tasks::Tasks,
     util::Timestamp,
 };
 
@@ -108,7 +108,7 @@ impl JsonRpcInterface {
     // --> {"jsonrpc": "2.0", "method": "list", "params": [], "id": 1}
     // <-- {"jsonrpc": "2.0", "result": [task, ...], "id": 1}
     async fn list(&self, _params: Value) -> TaudResult<Value> {
-        let tks = Tasks::load_current_open_tasks(&self.dataset_path)?;
+        let tks = MonthTasks::load_current_open_tasks(&self.dataset_path)?;
         Ok(json!(tks))
     }
 
@@ -207,7 +207,7 @@ impl JsonRpcInterface {
     fn load_task_by_id(&self, task_id: &Value) -> TaudResult<TaskInfo> {
         let task_id: u64 = serde_json::from_value(task_id.clone())?;
 
-        let tasks = Tasks::load_current_open_tasks(&self.dataset_path)?;
+        let tasks = MonthTasks::load_current_open_tasks(&self.dataset_path)?;
         let task = tasks.into_iter().find(|t| (t.get_id() as u64) == task_id);
 
         task.ok_or(TaudError::InvalidId)

bin/tau/taud/src/main.rs

@@ -18,15 +18,15 @@ use darkfi::{
 
 mod error;
 mod jsonrpc;
+mod month_tasks;
 mod task_info;
-mod tasks;
 mod util;
 
 use crate::{
     error::TaudResult,
     jsonrpc::JsonRpcInterface,
+    month_tasks::MonthTasks,
     task_info::TaskInfo,
-    tasks::Tasks,
     util::{CliTaud, Settings, TauConfig, CONFIG_FILE_CONTENTS},
 };
 
@@ -89,7 +89,7 @@ async fn start(settings: Settings, executor: Arc<Executor<'_>>) -> TaudResult<()
     let initial_sync: smol::Task<TaudResult<()>> = executor.spawn(async move {
         info!(target: "tau", "Start initial sync");
         info!(target: "tau", "Upload local tasks");
-        let tasks = Tasks::load_current_open_tasks(&dataset_path_cloned)?;
+        let tasks = MonthTasks::load_current_open_tasks(&dataset_path_cloned)?;
 
         for task in tasks {
             info!(target: "tau", "send local task {:?}", task);

bin/tau/taud/src/tasks.rs → bin/tau/taud/src/month_tasks.rs

@@ -1,20 +1,23 @@
 use std::path::{Path, PathBuf};
 
+use chrono::{TimeZone, Utc};
 use serde::{Deserialize, Serialize};
 
 use crate::{
     error::{TaudError, TaudResult},
     task_info::TaskInfo,
+    util::{get_current_time, Timestamp},
 };
 
 #[derive(Clone, Debug, Serialize, Deserialize, PartialEq)]
-pub struct Tasks {
+pub struct MonthTasks {
+    created_at: Timestamp,
     task_tks: Vec<String>,
 }
 
-impl Tasks {
+impl MonthTasks {
     pub fn new(task_tks: &[String]) -> Self {
-        Self { task_tks: task_tks.to_owned() }
+        Self { created_at: get_current_time(), task_tks: task_tks.to_owned() }
     }
 
     pub fn add(&mut self, ref_id: &str) {
@@ -39,28 +42,33 @@ impl Tasks {
         }
     }
 
-    fn get_path(dataset_path: &Path, state: &str) -> PathBuf {
-        dataset_path.join("log").join(state)
+    pub fn set_date(&mut self, date: &Timestamp) {
+        self.created_at = date.clone();
     }
 
-    pub fn save(&self, dataset_path: &Path, state: &str) -> TaudResult<()> {
-        crate::util::save::<Self>(&Self::get_path(dataset_path, state), self)
+    fn get_path(date: &Timestamp, dataset_path: &Path) -> PathBuf {
+        dataset_path.join("month").join(Utc.timestamp(date.0, 0).format("%m%y").to_string())
+    }
+
+    pub fn save(&self, dataset_path: &Path) -> TaudResult<()> {
+        crate::util::save::<Self>(&Self::get_path(&self.created_at, dataset_path), self)
             .map_err(TaudError::Darkfi)
     }
 
-    pub fn load_or_create(dataset_path: &Path, state: &str) -> TaudResult<Self> {
-        match crate::util::load::<Self>(&Self::get_path(dataset_path, state)) {
+    pub fn load_or_create(date: &Timestamp, dataset_path: &Path) -> TaudResult<Self> {
+        match crate::util::load::<Self>(&Self::get_path(date, dataset_path)) {
             Ok(mt) => Ok(mt),
             Err(_) => {
-                let mt = Self::new(&[]);
-                mt.save(dataset_path, state)?;
+                let mut mt = Self::new(&[]);
+                mt.set_date(date);
+                mt.save(dataset_path)?;
                 Ok(mt)
             }
         }
     }
 
     pub fn load_current_open_tasks(dataset_path: &Path) -> TaudResult<Vec<TaskInfo>> {
-        let mt = Self::load_or_create(dataset_path, "pending")?;
+        let mt = Self::load_or_create(&get_current_time(), dataset_path)?;
         Ok(mt.objects(dataset_path)?.into_iter().filter(|t| t.get_state() != "stop").collect())
     }
 }
@@ -83,7 +91,7 @@ mod tests {
         let path = PathBuf::from(TEST_DATA_PATH);
 
         // mkdir dataset_path if not exists
-        create_dir_all(path.join("log"))?;
+        create_dir_all(path.join("month"))?;
         create_dir_all(path.join("task"))?;
         Ok(path)
     }
@@ -111,24 +119,24 @@ mod tests {
 
         assert_eq!(task, t_load);
 
-        // load and save Tasks
+        // load and save MonthTasks
         ///////////////////////
 
         let task_tks = vec![];
 
-        let mut mt = Tasks::new(&task_tks);
+        let mut mt = MonthTasks::new(&task_tks);
 
-        mt.save(&dataset_path, "pending")?;
+        mt.save(&dataset_path)?;
 
-        let mt_load = Tasks::load_or_create(&dataset_path, "pending")?;
+        let mt_load = MonthTasks::load_or_create(&get_current_time(), &dataset_path)?;
 
         assert_eq!(mt, mt_load);
 
         mt.add(&task.ref_id);
 
-        mt.save(&dataset_path, "pending")?;
+        mt.save(&dataset_path)?;
 
-        let mt_load = Tasks::load_or_create(&dataset_path, "pending")?;
+        let mt_load = MonthTasks::load_or_create(&get_current_time(), &dataset_path)?;
 
         assert_eq!(mt, mt_load);
 
@@ -139,7 +147,7 @@ mod tests {
 
         task.save(&dataset_path)?;
 
-        let mt_load = Tasks::load_or_create(&dataset_path, "pending")?;
+        let mt_load = MonthTasks::load_or_create(&get_current_time(), &dataset_path)?;
 
         assert!(mt_load.task_tks.contains(&task.ref_id));
 

bin/tau/taud/src/task_info.rs

@@ -11,7 +11,7 @@ use darkfi::util::serial::VarInt;
 
 use crate::{
     error::{TaudError, TaudResult},
-    tasks::Tasks,
+    month_tasks::MonthTasks,
     util::{find_free_id, get_current_time, random_ref_id, Timestamp},
 };
 
@@ -78,7 +78,7 @@ impl TaskInfo {
         let created_at: Timestamp = get_current_time();
 
         let task_ids: Vec<u32> =
-            Tasks::load_current_open_tasks(dataset_path)?.into_iter().map(|t| t.id).collect();
+            MonthTasks::load_current_open_tasks(dataset_path)?.into_iter().map(|t| t.id).collect();
 
         let id: u32 = find_free_id(&task_ids);
 
@@ -122,18 +122,15 @@ impl TaskInfo {
     }
 
     pub fn activate(&self, path: &Path) -> TaudResult<()> {
-        let mut mt = Tasks::load_or_create(path, "pending")?;
+        let mut mt = MonthTasks::load_or_create(&self.created_at, path)?;
         mt.add(&self.ref_id);
-        mt.save(path, "pending")
+        mt.save(path)
     }
 
     pub fn deactivate(&self, path: &Path) -> TaudResult<()> {
-        let mut mt = Tasks::load_or_create(path, "pending")?;
-        let mut temp_mt = Tasks::load_or_create(path, "completed")?;
+        let mut mt = MonthTasks::load_or_create(&self.created_at, path)?;
         mt.remove(&self.ref_id);
-        mt.save(path, "pending")?;
-        temp_mt.add(&self.ref_id);
-        temp_mt.save(path, "completed")
+        mt.save(path)
     }
 
     pub fn get_state(&self) -> String {

bin/tau/taud/src/util.rs

@@ -72,7 +72,7 @@ impl Settings {
         let dataset_path = expand_path(&config.dataset_path)?;
 
         // mkdir dataset_path if not exists
-        create_dir_all(dataset_path.join("log"))?;
+        create_dir_all(dataset_path.join("month"))?;
         create_dir_all(dataset_path.join("task"))?;
 
         if config.datastore_raft.is_empty() {