caltemps 0.3.1

A tool to query and report on your iCalendar data from vDirs.
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

use chrono::{DateTime, Datelike, Local, TimeZone};
use icalendar::{Component, DatePerhapsTime};
use regex::Regex;
use std::cmp::{max, min};

use super::date_range::CalTempsDateRange;

#[derive(Debug, Clone)]
pub struct CalTempsEntry {
    pub is_event: bool,
    pub summary: String,
    pub description: String,
    pub start: Option<DateTime<Local>>,
    pub end: Option<DateTime<Local>>,
}

impl CalTempsEntry {
    pub fn duration_minutes(&self) -> Option<i64> {
        match self.start {
            Some(ds) => self.end.map(|de| (de - ds).num_minutes()),
            _ => None,
        }
    }
    pub fn date_range_intersection_minutes(&self, date_range: &CalTempsDateRange) -> Option<i64> {
        match self.start {
            Some(ds) => match self.end {
                Some(de) => {
                    let mins = (match date_range.end {
                        Some(dre) => min(de, dre),
                        _ => de,
                    } - match date_range.start {
                        Some(drs) => max(ds, drs),
                        _ => ds,
                    })
                    .num_minutes();
                    if mins < 0 { None } else { Some(mins) }
                }
                _ => None,
            },
            _ => None,
        }
    }
    fn get_matches(&self, pattern: &str) -> Vec<&str> {
        let re = Regex::new(pattern).unwrap();
        let mut v: Vec<_> = re.find_iter(&self.summary).map(|m| m.as_str()).collect();
        v.sort_by_cached_key(|t| t.to_lowercase());
        v
    }
    pub fn full_tags(&self) -> Vec<&str> {
        self.hash_tags()
            .into_iter()
            .chain(self.who_tags())
            .collect()
    }
    pub fn at_tags(&self) -> Vec<&str> {
        self.get_matches(r"([@][\w]+)")
    }
    pub fn hash_tags(&self) -> Vec<&str> {
        self.get_matches(r"([#][\w]+)")
    }
    pub fn plus_tags(&self) -> Vec<&str> {
        self.get_matches(r"([+][\w]+)")
    }
    pub fn minus_tags(&self) -> Vec<&str> {
        self.get_matches(r"([-][\w]+)")
    }
    pub fn star_tags(&self) -> Vec<&str> {
        self.get_matches(r"([*][\w]+)")
    }
    pub fn who_tags(&self) -> Vec<&str> {
        self.get_matches(r"([!][\w]+)")
    }
}

fn dpt_to_dt(dpt: Option<DatePerhapsTime>) -> Option<DateTime<Local>> {
    match dpt {
        Some(icalendar::DatePerhapsTime::DateTime(cdt)) => cdt.try_into_utc().map(|d| d.into()),
        Some(icalendar::DatePerhapsTime::Date(nd)) => Some(
            Local
                .with_ymd_and_hms(nd.year(), nd.month(), nd.day(), 0, 0, 0)
                .unwrap(),
        ),
        _ => None,
    }
}

fn get_matching_entry_basic(
    active_filter: String,
    date_range: &CalTempsDateRange,
    summary: Option<&str>,
    description: Option<&str>,
    start: Option<DateTime<Local>>,
    end: Option<DateTime<Local>>,
) -> Option<CalTempsEntry> {
    if let Some(summary_str) = summary {
        if summary_str.contains(&active_filter) {
            return match start {
                Some(dts) => {
                    if date_range.start.unwrap_or(dts) <= dts {
                        match end {
                            Some(dte) => {
                                if dte <= date_range.end.unwrap_or(dte) {
                                    Some(CalTempsEntry {
                                        summary: summary_str.into(),
                                        description: description.unwrap_or_default().into(),
                                        start,
                                        end,
                                        is_event: true,
                                    })
                                } else {
                                    // Ignore those not matching end
                                    None
                                }
                            }
                            // Ignore those without end data(!)
                            _ => None,
                        }
                    } else {
                        // Ignore not matching start data
                        None
                    }
                }
                // Ignoring those without start data
                _ => None,
            };
        }
    }
    // Ignoring invalid or non-matching summaries
    None
}

pub fn get_matching_entry(
    component: icalendar::CalendarComponent,
    active_filter: String,
    date_range: &CalTempsDateRange,
) -> Option<CalTempsEntry> {
    match component {
        icalendar::CalendarComponent::Event(item) => get_matching_entry_basic(
            active_filter,
            date_range,
            item.get_summary(),
            item.get_description(),
            dpt_to_dt(item.get_start()),
            dpt_to_dt(item.get_end()),
        ),
        // TODO: we may want to implement support for other components
        _ => None,
    }
}