aze 0.1.1

A time tracking tool heavenly inspired by watson
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

use std::ops::Add;

use chrono::{Duration, Local, NaiveDate};

use crate::models::Frame;

pub mod frame;

#[derive(Clone)]
pub struct Display {
    pub date: NaiveDate,
    pub frames: Vec<Frame>,
}

impl Display {
    pub fn new(date: NaiveDate, frames: Vec<Frame>) -> Self {
        Self { date, frames }
    }

    pub fn add_frame(&mut self, frame: Frame) {
        self.frames.push(frame);
    }

    pub fn insert_frame(&mut self, frame: Frame) {
        self.frames.insert(0, frame);
    }

    pub fn total_duration(&mut self) -> Duration {
        let mut duration = Duration::zero();
        let frames = self.frames.clone();
        for frame in frames {
            if frame.end.is_some() {
                duration = duration.add(frame.end.unwrap() - frame.start);
            } else {
                let now = Local::now().naive_local();
                duration = duration.add(now - frame.start)
            }
        }

        duration
    }
}

#[cfg(test)]
mod tests {
    use crate::{database::MyJsonType, models::Frame};
    use chrono::{Local, NaiveDate, NaiveDateTime};

    use super::Display;

    #[test]
    fn can_add_multiple_frames() {
        use serde_json::json;

        let frame1 = Frame {
            id: "1".to_string(),
            start: Local::now().naive_local(),
            end: Some(Local::now().naive_local()),
            last_update: Local::now().naive_local(),
            project: "1".to_string(),
            tags: MyJsonType(json!({})),
            deleted: false,
        };

        let frame2 = Frame {
            id: "2".to_string(),
            start: Local::now().naive_local(),
            end: Some(Local::now().naive_local()),
            last_update: Local::now().naive_local(),
            project: "1".to_string(),
            tags: MyJsonType(json!({})),
            deleted: false,
        };

        let display = Display {
            date: Local::now().date().naive_local(),
            frames: vec![frame1, frame2],
        };

        assert_eq!(display.frames.len(), 2);
    }

    #[test]
    fn duration_from_multiple_frames() {
        use serde_json::json;
        let start: NaiveDateTime = NaiveDate::from_ymd(2001, 1, 1).and_hms(10, 0, 0);
        let end: NaiveDateTime = NaiveDate::from_ymd(2001, 1, 1).and_hms(11, 0, 0);
        let frame1 = Frame {
            id: "1".to_string(),
            start,
            end: Some(end),
            last_update: Local::now().naive_local(),
            project: "1".to_string(),
            tags: MyJsonType(json!({})),
            deleted: false,
        };

        let frame2 = Frame {
            id: "2".to_string(),
            start,
            end: Some(end),
            last_update: Local::now().naive_local(),
            project: "1".to_string(),
            tags: MyJsonType(json!({})),
            deleted: false,
        };

        let mut display = Display {
            date: Local::now().date().naive_local(),
            frames: vec![frame1, frame2],
        };

        assert_eq!(2, display.total_duration().num_hours());
    }
}