ezcal 0.3.4

Ergonomic iCalendar + vCard library for Rust
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

use crate::common::property::Property;
use std::fmt;

/// The action type for an alarm.
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum AlarmAction {
    Audio,
    Display,
    Email,
    Other(String),
}

impl AlarmAction {
    pub fn parse(s: &str) -> Self {
        match s.to_uppercase().as_str() {
            "AUDIO" => AlarmAction::Audio,
            "DISPLAY" => AlarmAction::Display,
            "EMAIL" => AlarmAction::Email,
            other => AlarmAction::Other(other.to_string()),
        }
    }
}

impl fmt::Display for AlarmAction {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            AlarmAction::Audio => write!(f, "AUDIO"),
            AlarmAction::Display => write!(f, "DISPLAY"),
            AlarmAction::Email => write!(f, "EMAIL"),
            AlarmAction::Other(s) => write!(f, "{}", s),
        }
    }
}

/// A VALARM component (alarm/reminder).
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct Alarm {
    pub action: AlarmAction,
    pub trigger: String,
    pub description: Option<String>,
    pub summary: Option<String>,
    pub duration: Option<String>,
    pub repeat: Option<u32>,
    pub extra_properties: Vec<Property>,
}

impl Alarm {
    /// Create a new display alarm with the given trigger.
    ///
    /// The trigger should be a duration (e.g., `-PT15M` for 15 minutes before)
    /// or an absolute date-time.
    pub fn display(trigger: impl Into<String>, description: impl Into<String>) -> Self {
        Self {
            action: AlarmAction::Display,
            trigger: trigger.into(),
            description: Some(description.into()),
            summary: None,
            duration: None,
            repeat: None,
            extra_properties: Vec::new(),
        }
    }

    /// Create a new audio alarm with the given trigger.
    pub fn audio(trigger: impl Into<String>) -> Self {
        Self {
            action: AlarmAction::Audio,
            trigger: trigger.into(),
            description: None,
            summary: None,
            duration: None,
            repeat: None,
            extra_properties: Vec::new(),
        }
    }

    pub fn with_repeat(mut self, duration: impl Into<String>, repeat: u32) -> Self {
        self.duration = Some(duration.into());
        self.repeat = Some(repeat);
        self
    }

    pub(crate) fn to_properties(&self) -> Vec<Property> {
        let mut props = Vec::new();
        props.push(Property::new("ACTION", self.action.to_string()));
        props.push(Property::new("TRIGGER", &self.trigger));
        if let Some(ref desc) = self.description {
            props.push(Property::new("DESCRIPTION", desc));
        }
        if let Some(ref summary) = self.summary {
            props.push(Property::new("SUMMARY", summary));
        }
        if let Some(ref dur) = self.duration {
            props.push(Property::new("DURATION", dur));
        }
        if let Some(rep) = self.repeat {
            props.push(Property::new("REPEAT", rep.to_string()));
        }
        props.extend(self.extra_properties.clone());
        props
    }
}