devjournal 0.1.0

A dev first cli journaling tool
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

use crate::domain as domain_models;

use crate::utils::date;
use chrono::{Duration, NaiveDateTime};
use serde::{Deserialize, Serialize};
use uuid::Uuid;

#[derive(Debug, Serialize, Deserialize)]
pub struct Journal {
    pub id: Uuid,
    pub name: String,
    pub pages: Vec<domain_models::Page>,
}

impl Journal {
    /// Create new entry model
    pub fn new(name: impl Into<String>) -> Self {
        let id = Uuid::new_v4();

        Journal {
            id,
            name: name.into(),
            pages: Vec::new(),
        }
    }

    /// Get todays page from journal
    pub fn todays_page(&mut self) -> &mut domain_models::Page {
        if self.pages.is_empty() {
            let page = domain_models::Page::new(date::now());
            self.add_page(page);
        }

        self.pages.last_mut().unwrap()
    }

    /// Get page for a specified date
    pub fn get_page(&mut self, date: &NaiveDateTime) -> Option<&mut domain_models::Page> {
        println!("looking for {}", date.date());
        for page in &self.pages {
            println!("{}", page.date);
        }
        self.pages
            .iter_mut()
            .find(|page| page.date.date() == date.date())
    }

    /// Add page to journal
    pub fn add_page(&mut self, page: domain_models::Page) {
        self.pages.push(page);
    }

    pub fn add_entry(&mut self, entry: domain_models::Entry) {
        if let Some(page) = self.get_page(&entry.date) {
            page.add_entry(entry);
        } else {
            // Page doesn't exist, so create and add one
            let mut new_page = domain_models::Page::new(entry.date);
            new_page.add_entry(entry);
            self.add_page(new_page);
        }
    }

    pub fn get_page_in_date_range(
        &self,
        from: NaiveDateTime,
        to: Option<NaiveDateTime>,
    ) -> Vec<&domain_models::Page> {
        let to_date = to.unwrap_or_else(|| date::now() + Duration::days(1));

        self.pages
            .iter()
            .filter(|page| from.date() <= page.date.date())
            .filter(|page| page.date.date() <= to_date.date())
            .collect()
    }
}