rust-cli-pomodoro 1.3.0

rust-cli-pomodoro manages your time! 
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

use chrono::{prelude::*, Duration};
use tabled::Tabled;

use crate::notification::Notification;

pub struct ArchivedNotification {
    id: u16,
    description: String,
    work_time: u16,
    break_time: u16,
    // TODO(young): Maybe we don't need created_at field for ArchivedNotification
    created_at: DateTime<Utc>,
    work_expired_at: DateTime<Utc>,
    break_expired_at: DateTime<Utc>,
}

impl From<Notification> for ArchivedNotification {
    fn from(n: Notification) -> Self {
        let (id, desc, wt, bt, created_at, w_expired_at, b_expired_at) = n.get_values();

        ArchivedNotification {
            id,
            description: desc.to_string(),
            work_time: wt,
            break_time: bt,
            created_at,
            work_expired_at: w_expired_at,
            break_expired_at: b_expired_at,
        }
    }
}

impl ArchivedNotification {
    pub fn get_start_at(&self) -> DateTime<Utc> {
        let last_expired_at = self.work_expired_at.max(self.break_expired_at);
        let duration = Duration::minutes((self.work_time + self.break_time) as i64);

        last_expired_at - duration
    }
}

impl Tabled for ArchivedNotification {
    const LENGTH: usize = 7;

    fn fields(&self) -> Vec<String> {
        let id = self.id.to_string();

        let started_at = {
            let local_time: DateTime<Local> = self.get_start_at().into();
            local_time.format("%F %T %z").to_string()
        };

        let description = self.description.to_string();

        let work_expired_at = if self.work_time > 0 {
            let local_time: DateTime<Local> = self.work_expired_at.into();
            local_time.format("%F %T %z").to_string()
        } else {
            String::from("N/A")
        };

        let break_expired_at = if self.break_time > 0 {
            let local_time: DateTime<Local> = self.break_expired_at.into();
            local_time.format("%F %T %z").to_string()
        } else {
            String::from("N/A")
        };

        vec![
            id,
            self.work_time.to_string(),
            self.break_time.to_string(),
            started_at,
            work_expired_at,
            break_expired_at,
            description,
        ]
    }

    fn headers() -> Vec<String> {
        vec![
            "id",
            "work_time",
            "break_time",
            "started_at",
            "expired_at (work)",
            "expired_at (break)",
            "description",
        ]
        .into_iter()
        .map(|x| x.to_string())
        .collect()
    }
}

#[cfg(test)]
mod tests {
    use crate::notification::Notification;
    use chrono::Utc;
    use tabled::Tabled;

    use super::ArchivedNotification;

    #[test]
    fn test_archived_notification_conversion() {
        let now = Utc::now();
        let notification = Notification::new(0, 25, 5, now);
        let archived_notification = ArchivedNotification::from(notification);

        assert_eq!(
            now.to_rfc3339_opts(chrono::SecondsFormat::Millis, true),
            archived_notification
                .get_start_at()
                .to_rfc3339_opts(chrono::SecondsFormat::Millis, true)
        );
    }

    #[test]
    fn test_archived_notification_tabled_impl() {
        let now = Utc::now();
        let notification = Notification::new(0, 25, 5, now);
        let archived_notification = ArchivedNotification::from(notification);

        let fields = archived_notification.fields();
        assert_eq!(7, fields.len());

        let headers = ArchivedNotification::headers();
        assert_eq!(7, headers.len());
        assert_eq!(
            vec![
                "id".to_string(),
                "work_time".to_string(),
                "break_time".to_string(),
                "started_at".to_string(),
                "expired_at (work)".to_string(),
                "expired_at (break)".to_string(),
                "description".to_string(),
            ],
            headers
        );
    }
}