libdav 0.10.3

CalDAV and CardDAV client implementations.
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

// Copyright 2023-2024 Hugo Osvaldo Barrera
//
// SPDX-License-Identifier: ISC

//! An example of some basic usage of the `CalDavClient` type.
//!
//! Usage:
//!
//!     cargo run --example=find_calendars https://example.com user@example.com MYPASSWORD
//!     cargo run --example=find_calendars $SERVER_URL         $USERNAME        $PASSWORD
//!
//! Example output (with `$1 = "https://fastmail.com"`):
//!
//! ```
//! Resolved server URL to: https://d277161.caldav.fastmail.com/dav/calendars
//! found 1 calendars...
//! 📅 name: Some("Calendar"), colour: Some("#3a429c"), path: "/dav/calendars/user/vdirsyncer@fastmail.com/cc396171-0227-4e1c-b5ee-d42b5e17d533/"
//! Href and Etag for components in calendar:
//! - /dav/calendars/user/vdirsyncer@fastmail.com/cc396171-0227-4e1c-b5ee-d42b5e17d533/395b00a0-eebc-40fd-a98e-176a06367c82.ics, "e7577ff2b0924fe8e9a91d3fb2eb9072598bf9fb"
//! ```
use http::Uri;
use hyper_rustls::HttpsConnectorBuilder;
use hyper_util::client::legacy::Client;
use hyper_util::rt::TokioExecutor;
use libdav::caldav::{FindCalendarHomeSet, FindCalendars, GetSupportedComponents};
use libdav::dav::{GetProperty, ListResources, WebDavClient};
use libdav::{CalDavClient, names};
use tower_http::auth::AddAuthorization;

#[tokio::main(flavor = "current_thread")]
async fn main() {
    let mut arguments = std::env::args();
    arguments
        .next()
        .expect("binary has been called with a name");
    let base_url: Uri = arguments
        .next()
        .expect("$1 is defined")
        .parse()
        .expect("$1 is a valid URL");
    let username = arguments.next().expect("$2 is a valid username");
    let password = arguments.next().expect("$3 is a valid password");

    let https_connector = HttpsConnectorBuilder::new()
        .with_native_roots()
        .expect("native TLS roots should be available")
        .https_or_http()
        .enable_http1()
        .build();
    let https_client = Client::builder(TokioExecutor::new()).build(https_connector);
    let https_client = AddAuthorization::basic(https_client, &username, &password);
    let webdav = WebDavClient::new(base_url, https_client);
    let caldav_client = CalDavClient::bootstrap_via_service_discovery(webdav)
        .await
        .unwrap();

    let urls = match caldav_client.find_current_user_principal().await.unwrap() {
        Some(principal) => {
            let home_set = caldav_client
                .request(FindCalendarHomeSet::new(&principal))
                .await
                .unwrap()
                .home_sets;
            if home_set.is_empty() {
                vec![caldav_client.base_url().clone()]
            } else {
                home_set
            }
        }
        None => vec![caldav_client.base_url().clone()],
    };

    for url in urls {
        let calendars = caldav_client
            .request(FindCalendars::new(&url))
            .await
            .unwrap()
            .calendars;

        println!("found {} calendars...", calendars.len());

        for calendar in calendars {
            let name = caldav_client
                .request(GetProperty::new(&calendar.href, &names::DISPLAY_NAME))
                .await
                .unwrap()
                .value;
            let color = caldav_client
                .request(GetProperty::new(&calendar.href, &names::CALENDAR_COLOUR))
                .await
                .unwrap()
                .value;
            let comps = caldav_client
                .request(GetSupportedComponents::new(&calendar.href))
                .await
                .unwrap()
                .components;
            let capabilities = if comps.is_empty() {
                "(none advertised)".to_string()
            } else {
                comps
                    .iter()
                    .map(|c| c.as_str().to_string())
                    .collect::<Vec<_>>()
                    .join(", ")
            };
            println!(
                "📅 name: {name:?}, colour: {color:?}, path: {:?}, etag: {:?}, capabilities: {}",
                &calendar.href, &calendar.etag, capabilities
            );

            let items = caldav_client
                .request(ListResources::new(&calendar.href))
                .await
                .unwrap()
                .resources
                .into_iter()
                .filter(|i| !i.resource_type.is_collection);
            for item in items {
                println!("   {}, {}", item.href, item.etag.unwrap());
            }
        }
    }
}