oxinbox-core 0.1.0

Shared data types for the oxinbox GTD productivity system
Documentation 
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
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152

use chrono::{DateTime, NaiveDate, Utc};
use serde::{Deserialize, Serialize};

pub use uuid::Uuid;

pub use chrono;
pub use serde;
pub use uuid;

#[derive(Debug, Serialize, Deserialize, Clone, PartialEq, Eq)]
#[serde(rename_all = "lowercase")]
pub enum TaskStatus {
    Inbox,
    Todo,
    Doing,
    Done,
    Someday,
}

#[derive(Debug, Serialize, Deserialize, Clone, PartialEq, Eq)]
pub struct Task {
    pub id: Uuid,
    pub completed: bool,
    pub priority: Option<char>,
    pub description: String,
    pub projects: Vec<String>,
    pub contexts: Vec<String>,
    pub status: TaskStatus,
    pub created_at: DateTime<Utc>,
    pub updated_at: DateTime<Utc>,
    pub completed_at: Option<DateTime<Utc>>,
    pub due_date: Option<NaiveDate>,
}

#[derive(Debug, Serialize, Deserialize, Clone)]
pub struct TaskHistory {
    pub id: i32,
    pub task_id: Uuid,
    pub from_status: Option<TaskStatus>,
    pub to_status: TaskStatus,
    pub changed_at: DateTime<Utc>,
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn task_creation_with_uuid_v7() {
        let task = Task {
            id: Uuid::now_v7(),
            completed: false,
            priority: None,
            description: "Test task".into(),
            projects: vec![],
            contexts: vec![],
            status: TaskStatus::Inbox,
            created_at: Utc::now(),
            updated_at: Utc::now(),
            completed_at: None,
            due_date: None,
        };
        assert_eq!(task.id.get_version(), Some(uuid::Version::SortRand));
    }

    #[test]
    fn task_serialize_deserialize_roundtrip() {
        let task = Task {
            id: Uuid::now_v7(),
            completed: false,
            priority: Some('A'),
            description: "Buy milk +proyecto @casa".into(),
            projects: vec!["proyecto".into()],
            contexts: vec!["casa".into()],
            status: TaskStatus::Todo,
            created_at: Utc::now(),
            updated_at: Utc::now(),
            completed_at: None,
            due_date: Some(NaiveDate::from_ymd_opt(2026, 7, 10).unwrap()),
        };
        let json = serde_json::to_string(&task).unwrap();
        let deserialized: Task = serde_json::from_str(&json).unwrap();
        assert_eq!(task.id, deserialized.id);
        assert_eq!(task.description, deserialized.description);
        assert_eq!(task.status, deserialized.status);
    }

    #[test]
    fn task_status_serialization() {
        let statuses = vec![
            (TaskStatus::Inbox, "\"inbox\""),
            (TaskStatus::Todo, "\"todo\""),
            (TaskStatus::Doing, "\"doing\""),
            (TaskStatus::Done, "\"done\""),
            (TaskStatus::Someday, "\"someday\""),
        ];
        for (status, expected) in statuses {
            assert_eq!(serde_json::to_string(&status).unwrap(), expected);
        }
    }

    #[test]
    fn task_history_creation() {
        let history = TaskHistory {
            id: 1,
            task_id: Uuid::now_v7(),
            from_status: Some(TaskStatus::Inbox),
            to_status: TaskStatus::Doing,
            changed_at: Utc::now(),
        };
        assert_eq!(history.from_status, Some(TaskStatus::Inbox));
        assert_eq!(history.to_status, TaskStatus::Doing);
    }

    #[test]
    fn task_default_status_is_inbox() {
        let task = Task {
            id: Uuid::now_v7(),
            completed: false,
            priority: None,
            description: "test".into(),
            projects: vec![],
            contexts: vec![],
            status: TaskStatus::Inbox,
            created_at: Utc::now(),
            updated_at: Utc::now(),
            completed_at: None,
            due_date: None,
        };
        assert_eq!(task.status, TaskStatus::Inbox);
        assert!(!task.completed);
    }

    #[test]
    fn completed_task_has_completed_at() {
        let task = Task {
            id: Uuid::now_v7(),
            completed: true,
            priority: None,
            description: "Done task".into(),
            projects: vec![],
            contexts: vec![],
            status: TaskStatus::Done,
            created_at: Utc::now(),
            updated_at: Utc::now(),
            completed_at: Some(Utc::now()),
            due_date: None,
        };
        assert!(task.completed);
        assert!(task.completed_at.is_some());
    }
}