calpoll / src / calendar.rs

use std::ops::DerefMut;
use axum::extract::Path;
use fast_dav_rs::CalDavClient;
use icalendar::Component;
use leptos::prelude::ServerFnError;
use leptos::server;
use tokio::task::JoinSet;
use uuid::Uuid;

use crate::STATE;

pub(crate) async fn route(
    Path(id): Path<Uuid>
) -> String {
    events_by_calendar(id).await.unwrap()
}

#[server]
async fn events_by_calendar(id: Uuid) -> anyhow::Result<String, ServerFnError> {
    let state = STATE.get().expect("Failed to get STATE - is it set yet?");

    let subscriptions = sqlx::query!(
        r#"SELECT subscriptions.reference, dav_connections.url as "dav_connection_url?", dav_connections.username, dav_connections.password FROM subscriptions
         JOIN calendars_subscriptions on subscriptions.id = calendars_subscriptions.subscriptions_id
         JOIN calendars on calendars.id = calendars_subscriptions.calendars_id
         LEFT JOIN dav_connections on subscriptions.dav_connection = dav_connections.id
         WHERE calendars.id = $1"#,
        id
    ).fetch_all(state.sqlx_connection.lock().await.deref_mut()).await?;

    let mut requests = JoinSet::new();

    for subscription in subscriptions {
        requests.spawn((async || {
            if let (Some(dav_connection_url), username, password) = (subscription.dav_connection_url, subscription.username, subscription.password) {
                // fast_dav_rs client doesn't follow redirects, so we must use reqwest to check first so, e.g., stalwart .well-known/caldav URLs work
                let base_url = state.reqwest_client.head(&dav_connection_url).send().await
                        .and_then(|response| Ok(response.url().to_string()))
                        .unwrap_or_else(|_| dav_connection_url);

                let Ok(client) = CalDavClient::new(&base_url, username.as_deref(), password.as_deref()) else {
                    return None
                };
                
                return get_dav_calendar(client, &subscription.reference).await
            }
            let result = state.reqwest_client.get(subscription.reference).send().await;

            let Ok(response) = result else {
                return None
            };
            
            let Ok(text) = response.text().await else {
                return None
            };

            text.parse::<icalendar::Calendar>().ok()
        })());
    }

    let calendars = requests.join_all().await;

    let mut merged = icalendar::Calendar::new();

    for maybe_calendar in calendars {
        if let Some(calendar) = maybe_calendar {
            merged.extend(calendar.components);
        }
    }

    Ok(merged.to_string())
}

#[cfg(feature = "ssr")]
async fn list_dav_calendars(client: &CalDavClient) -> anyhow::Result<Vec<fast_dav_rs::CalendarInfo>, anyhow::Error> {
    let Some(principal) = client.discover_current_user_principal().await? else {
        return Err(anyhow::anyhow!("Incompatible: CalDav server does not indicate principal"))
    };

    let home_sets = client.discover_calendar_home_set(&principal).await?;

    let mut calendars = vec![];

    for home_set in home_sets {
        calendars.extend(client.list_calendars(&home_set).await?);
    }

    Ok(calendars)
}

fn get_colored_components(color: Option<&str>, calendar: icalendar::Calendar) -> Vec<icalendar::CalendarComponent> {   
    let Some(color) = calendar.property_value("COLOR").or_else(|| color) else {
        return calendar.components
    };

    return calendar.components.iter().map(ToOwned::to_owned).map(|component| {
        match component {
            icalendar::CalendarComponent::Event(mut event) => {
                if event.property_value("COLOR").is_none() {
                    event.add_property("COLOR", color);
                }

                icalendar::CalendarComponent::Event(event)
            },
            icalendar::CalendarComponent::Todo(mut todo) => {
                if todo.property_value("COLOR").is_none() {
                    todo.add_property("COLOR", color);
                }

                icalendar::CalendarComponent::Todo(todo)
            },
            icalendar::CalendarComponent::Venue(mut venue) => {
                if venue.property_value("COLOR").is_none() {
                    venue.add_property("COLOR", color);
                }

                icalendar::CalendarComponent::Venue(venue)
            },
            other => other
        }
    }).collect()
}

#[cfg(feature = "ssr")]
async fn get_dav_calendar(client: fast_dav_rs::CalDavClient, reference: &str) -> Option<icalendar::Calendar> {
    let all_calendars = list_dav_calendars(&client).await.unwrap_or_else(|_| vec![]);

    let color = all_calendars
        .iter()
        .filter(|calendar| calendar.href == reference && calendar.color.is_some())
        .next()
        .and_then(|calendar| calendar.color.clone());
    
    let Ok(result) = client.calendar_query_timerange(reference, "VEVENT", None, None, true).await else {
        return None
    };
    
    let mut calendar = icalendar::Calendar::new();

    for calendar_object in result {
        let Some(calendar_data) = calendar_object.calendar_data else {
            continue
        };

        let Ok(parsed) = calendar_data.parse::<icalendar::Calendar>() else {
            continue
        };

        calendar.extend(get_colored_components(color.as_deref(), parsed))
    }

    Some(calendar)
}