gcal_rs 0.1.2

A blazingly fast, hand written Google calendar API in 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
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121

use super::{ClientResult, Event, Events, GCalClient, SendUpdates};

/// EventClient is the method of managing events from a specific calendar. Requires a Google
/// Calendar client.
pub struct EventClient(GCalClient);

impl EventClient {
    /// Construct a new EventClient. Requires a Google Calendar Client.
    pub fn new(client: GCalClient) -> Self {
        Self(client)
    }

    /// Delete the event.
    pub async fn delete(&self, event: Event) -> ClientResult<()> {
        self.0.delete(None, event).await?;
        Ok(())
    }

    /// Get an event by ID.
    pub async fn get(&self, calendar_id: String, event_id: String) -> ClientResult<Event> {
        let event = Event {
            id: event_id,
            calendar_id: Some(calendar_id),
            ..Default::default()
        };
        Ok(self.0.get(None, event).await?.json().await?)
    }

    /// Import an event. See the Google Calendar documentation for the differences between import
    /// and insert.
    pub async fn import(&self, event: Event) -> ClientResult<Event> {
        Ok(self
            .0
            .post(Some("import".to_string()), event)
            .await?
            .json()
            .await?)
    }

    /// Insert an event. See the Google Calendar documentation for the differences between import
    /// and insert.
    pub async fn insert(&self, mut event: Event) -> ClientResult<Event> {
        if let Some(attachments) = event.attachments.clone() {
            if !attachments.is_empty() {
                event.add_query("supportsAttachments".to_string(), "true".to_string());
            }
        }
        Ok(self
            .0
            .post(Some(String::new()), event)
            .await?
            .json()
            .await?)
    }

    /// Retrieve all instances for a recurring event.
    pub async fn instances(&self, event: Event) -> ClientResult<Events> {
        Ok(self
            .0
            .get(Some("instances".to_string()), event)
            .await?
            .json()
            .await?)
    }

    /// List events between the start and end times.
    pub async fn list(
        &self,
        calendar_id: String,
        start_time: chrono::DateTime<chrono::Local>,
        end_time: chrono::DateTime<chrono::Local>,
    ) -> ClientResult<Vec<Event>> {
        let mut event = Event {
            calendar_id: Some(calendar_id.clone()),
            ..Default::default()
        };
        event.add_query("timeMin".to_string(), start_time.to_rfc3339());
        event.add_query("timeMax".to_string(), end_time.to_rfc3339());
        event.add_query("singleEvents".to_string(), "true".to_string());
        event.add_query("orderBy".to_string(), "startTime".to_string());

        let mut events = self.0.get(None, event).await?.json::<Events>().await?;
        events.add_calendar(calendar_id);
        Ok(events.items)
    }

    /// Move event to another destination calendar_id.
    pub async fn move_to_calendar(
        &self,
        mut event: Event,
        destination: String,
        send_updates: Option<SendUpdates>,
    ) -> ClientResult<()> {
        event.add_query("destination".to_string(), destination);
        event.add_query(
            "sendUpdates".to_string(),
            send_updates.map_or_else(|| "false".to_string(), |x| x.to_string()),
        );

        self.0.post(Some("move".to_string()), event).await?;
        Ok(())
    }

    /// Add an event with the summary.
    pub async fn add(&self, text: String) -> ClientResult<Event> {
        let mut event = Event::default();
        event.add_query("text".to_string(), text);

        Ok(self
            .0
            .post(Some("quickAdd".to_string()), event)
            .await?
            .json()
            .await?)
    }

    /// Update an event.
    pub async fn update(&self, event: Event) -> ClientResult<Event> {
        Ok(self.0.put(None, event).await?.json().await?)
    }
}