tally-todo 0.5.2

Make TODO management a little more automatic
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67

use crate::models::common::{Priority, Version};
use chrono::{DateTime, Utc};
use serde::{Deserialize, Serialize};

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Task {
    pub description: String,
    pub priority: Priority,
    pub tags: Vec<String>,
    pub completed: bool,

    // Creation metadata
    pub created_at_time: DateTime<Utc>,
    pub created_at_version: Option<Version>,
    pub created_at_commit: Option<String>,

    // Completion metadata
    pub completed_at_time: Option<DateTime<Utc>>,
    pub completed_at_version: Option<Version>,
    pub completed_at_commit: Option<String>,
}

impl Task {
    /// Create a new incomplete task
    pub fn new(description: impl Into<String>, priority: Priority, tags: Vec<String>) -> Self {
        Self {
            description: description.into(),
            priority,
            tags,
            completed: false,
            created_at_time: Utc::now(),
            created_at_version: None,
            created_at_commit: None,
            completed_at_time: None,
            completed_at_version: None,
            completed_at_commit: None,
        }
    }

    /// Mark task as complete
    pub fn mark_complete(&mut self, commit: Option<String>, version: Option<Version>) {
        self.completed = true;
        self.completed_at_time = Some(Utc::now());
        self.completed_at_commit = commit;
        self.completed_at_version = version;
    }

    /// Check if task matches any of the given tags
    pub fn has_any_tag(&self, tags: &[String]) -> bool {
        tags.iter().any(|t| self.tags.contains(t))
    }

    /// Check if task has all given tags
    pub fn has_all_tags(&self, tags: &[String]) -> bool {
        tags.iter().all(|t| self.tags.contains(t))
    }

    /// Check if task is older than given duration (in days)
    pub fn is_older_than_days(&self, days: u32) -> bool {
        if let Some(completed_time) = self.completed_at_time {
            let age = Utc::now().signed_duration_since(completed_time);
            age.num_days() > days as i64
        } else {
            false
        }
    }
}