From e721860e0381e62ed96c7b74eb08ad08551fc031 Mon Sep 17 00:00:00 2001 From: ghassmo Date: Sat, 26 Mar 2022 16:01:24 +0400 Subject: [PATCH] bin/taud: impl Encodable/Decodable for TaskInfo --- bin/taud/src/task_info.rs | 181 ++++++++++++++++++++++++++++++++++---- 1 file changed, 165 insertions(+), 16 deletions(-) diff --git a/bin/taud/src/task_info.rs b/bin/taud/src/task_info.rs index 82edd815c..81802f124 100644 --- a/bin/taud/src/task_info.rs +++ b/bin/taud/src/task_info.rs @@ -1,8 +1,13 @@ -use std::path::PathBuf; +use std::{io, path::PathBuf}; use serde::{Deserialize, Serialize}; -use darkfi::Result; +use darkfi::{ + util::serial::{Decodable, Encodable}, + Result, +}; + +use darkfi::util::serial::VarInt; use crate::{ month_tasks::MonthTasks, @@ -10,7 +15,6 @@ use crate::{ }; #[derive(Clone, Debug, Serialize, Deserialize, PartialEq)] - struct TaskEvent { action: String, timestamp: Timestamp, @@ -35,6 +39,15 @@ impl Comment { } } +#[derive(Clone, Debug, Serialize, Deserialize, PartialEq)] +struct TaskEvents(Vec); +#[derive(Clone, Debug, Serialize, Deserialize, PartialEq)] +struct TaskComments(Vec); +#[derive(Clone, Debug, Serialize, Deserialize, PartialEq)] +struct TaskProjects(Vec); +#[derive(Clone, Debug, Serialize, Deserialize, PartialEq)] +struct TaskAssigns(Vec); + // XXX #[allow(dead_code)] #[derive(Clone, Debug, Serialize, Deserialize, PartialEq)] @@ -43,13 +56,13 @@ pub struct TaskInfo { id: u32, title: String, desc: String, - assign: Vec, - project: Vec, + assign: TaskAssigns, + project: TaskProjects, due: Option, rank: u32, created_at: Timestamp, - events: Vec, - comments: Vec, + events: TaskEvents, + comments: TaskComments, #[serde(skip_serializing, skip_deserializing)] settings: Settings, } @@ -76,13 +89,13 @@ impl TaskInfo { id, title: title.into(), desc: desc.into(), - assign: vec![], - project: vec![], + assign: TaskAssigns(vec![]), + project: TaskProjects(vec![]), due, rank, created_at, - comments: vec![], - events: vec![], + comments: TaskComments(vec![]), + events: TaskEvents(vec![]), settings: settings.clone(), }) } @@ -104,7 +117,7 @@ impl TaskInfo { } pub fn get_state(&self) -> String { - if let Some(ev) = self.events.last() { + if let Some(ev) = self.events.0.last() { ev.action.clone() } else { "open".into() @@ -132,15 +145,15 @@ impl TaskInfo { } pub fn set_assign(&mut self, assign: &Vec) { - self.assign = assign.clone(); + self.assign = TaskAssigns(assign.clone()); } pub fn set_project(&mut self, project: &Vec) { - self.project = project.clone(); + self.project = TaskProjects(project.clone()); } pub fn set_comment(&mut self, c: Comment) { - self.comments.push(c); + self.comments.0.push(c); } pub fn set_rank(&mut self, r: u32) { @@ -159,6 +172,142 @@ impl TaskInfo { if self.get_state() == action { return } - self.events.push(TaskEvent::new(action.into())); + self.events.0.push(TaskEvent::new(action.into())); } } + +impl Encodable for TaskEvent { + fn encode(&self, mut s: S) -> Result { + let mut len = 0; + len += self.action.encode(&mut s)?; + len += self.timestamp.encode(&mut s)?; + Ok(len) + } +} + +impl Decodable for TaskEvent { + fn decode(mut d: D) -> Result { + Ok(Self { action: Decodable::decode(&mut d)?, timestamp: Decodable::decode(&mut d)? }) + } +} + +impl Encodable for Comment { + fn encode(&self, mut s: S) -> Result { + let mut len = 0; + len += self.content.encode(&mut s)?; + len += self.author.encode(&mut s)?; + len += self.timestamp.encode(&mut s)?; + Ok(len) + } +} + +impl Decodable for Comment { + fn decode(mut d: D) -> Result { + Ok(Self { + content: Decodable::decode(&mut d)?, + author: Decodable::decode(&mut d)?, + timestamp: Decodable::decode(&mut d)?, + }) + } +} + +impl Encodable for TaskInfo { + fn encode(&self, mut s: S) -> Result { + let mut len = 0; + len += self.ref_id.encode(&mut s)?; + len += self.id.encode(&mut s)?; + len += self.title.encode(&mut s)?; + len += self.desc.encode(&mut s)?; + len += self.assign.encode(&mut s)?; + len += self.project.encode(&mut s)?; + len += self.due.encode(&mut s)?; + len += self.rank.encode(&mut s)?; + len += self.created_at.encode(&mut s)?; + len += self.events.encode(&mut s)?; + len += self.comments.encode(&mut s)?; + Ok(len) + } +} + +impl Decodable for TaskInfo { + fn decode(mut d: D) -> Result { + Ok(Self { + ref_id: Decodable::decode(&mut d)?, + id: Decodable::decode(&mut d)?, + title: Decodable::decode(&mut d)?, + desc: Decodable::decode(&mut d)?, + assign: Decodable::decode(&mut d)?, + project: Decodable::decode(&mut d)?, + due: Decodable::decode(&mut d)?, + rank: Decodable::decode(&mut d)?, + created_at: Decodable::decode(&mut d)?, + events: Decodable::decode(&mut d)?, + comments: Decodable::decode(&mut d)?, + settings: Settings::default(), + }) + } +} + +impl Encodable for TaskEvents { + fn encode(&self, s: S) -> Result { + encode_vec(&self.0, s) + } +} + +impl Decodable for TaskEvents { + fn decode(d: D) -> Result { + Ok(Self(decode_vec(d)?)) + } +} +impl Encodable for TaskComments { + fn encode(&self, s: S) -> Result { + encode_vec(&self.0, s) + } +} + +impl Decodable for TaskComments { + fn decode(d: D) -> Result { + Ok(Self(decode_vec(d)?)) + } +} +impl Encodable for TaskProjects { + fn encode(&self, s: S) -> Result { + encode_vec(&self.0, s) + } +} + +impl Decodable for TaskProjects { + fn decode(d: D) -> Result { + Ok(Self(decode_vec(d)?)) + } +} + +impl Encodable for TaskAssigns { + fn encode(&self, s: S) -> Result { + encode_vec(&self.0, s) + } +} + +impl Decodable for TaskAssigns { + fn decode(d: D) -> Result { + Ok(Self(decode_vec(d)?)) + } +} + +fn encode_vec(vec: &Vec, mut s: S) -> Result { + let mut len = 0; + len += VarInt(vec.len() as u64).encode(&mut s)?; + for c in vec.iter() { + len += c.encode(&mut s)?; + } + Ok(len) +} + +fn decode_vec(mut d: D) -> Result> { + let len = VarInt::decode(&mut d)?.0; + let mut ret = Vec::with_capacity(len as usize); + for _ in 0..len { + ret.push(Decodable::decode(&mut d)?); + } + Ok(ret) +}