refactor

src/wac_ical.rs

@@ -0,0 +1,261 @@
+//! Structs and functions specific to gathering input from ics files, which is a popular format that Google Calendar happens to put out
+
+use super::{CalendarUi, DatePerhapsTime, Downloadable, EventInstance, Parameters, RecurrenceKey};
+use anyhow::{Context as _, Result, anyhow};
+use base64::Engine as _;
+use chrono::TimeZone as _;
+use icalendar::{Component as _, EventLike as _};
+use serde::Deserialize;
+use std::{collections::BTreeSet, str::FromStr as _};
+
+/// Google Calendar has a public ics endpoint that we scrape for all upstream Google Calendars
+#[derive(Clone, Default, Deserialize)]
+pub(crate) struct Config {
+    #[serde(flatten)]
+    pub(crate) dl: Downloadable,
+
+    /// Magical ID we pass to Google to deep-link to Google Calendar events
+    google_id: Option<String>,
+
+    #[serde(flatten)]
+    pub(crate) ui: CalendarUi,
+}
+
+pub(crate) struct Calendar {
+    /// The parsed ics file
+    cal: icalendar::Calendar,
+
+    /// The config used to load this calendar
+    config: Config,
+}
+
+fn normalize_date_perhaps_time(
+    x: &icalendar::DatePerhapsTime,
+    tz: chrono_tz::Tz,
+) -> Result<DatePerhapsTime> {
+    Ok(match x {
+        icalendar::DatePerhapsTime::DateTime(x) => {
+            let dt = x
+                .try_into_utc()
+                .context("Data error - Could not convert event datetime to UTC")?
+                .with_timezone(&tz);
+            DatePerhapsTime { dt, all_day: false }
+        }
+        icalendar::DatePerhapsTime::Date(date) => {
+            let midnight = chrono::NaiveTime::default();
+            let dt = tz.from_local_datetime(&date.and_time(midnight)).single().context("DateTime doesn't map to a single unambiguous datetime when converting to our timezone")?;
+            DatePerhapsTime { dt, all_day: true }
+        }
+    })
+}
+
+fn recurring_dates_opt(
+    params: &Parameters,
+    ev: &icalendar::Event,
+    rrule: &icalendar::Property,
+) -> Result<Option<impl Iterator<Item = DatePerhapsTime>>> {
+    let dtstart = ev
+        .get_start()
+        .context("Data error - Event has no DTSTART")?;
+    let all_day = match &dtstart {
+        icalendar::DatePerhapsTime::Date(_) => true,
+        icalendar::DatePerhapsTime::DateTime(_) => false,
+    };
+    let dtstart_norm = normalize_date_perhaps_time(&dtstart, params.tz)?;
+
+    let rr = rrule::RRule::from_str(rrule.value())
+        .with_context(|| format!("RRule parse failed `{}`", rrule.value()))?;
+
+    if let Some(until) = rr.get_until()
+        && *until < params.output_start
+    {
+        // This skips over some bad data in our test set where we fail to parse a recurring event that's already ended before our output window starts
+        return Ok(None);
+    }
+
+    let rrule_tz = params.tz.into();
+
+    let rr = rr.build(dtstart_norm.dt.with_timezone(&rrule_tz))?;
+    let dates = rr
+        .after(params.output_start.with_timezone(&rrule_tz))
+        .before(params.output_stop.with_timezone(&rrule_tz))
+        .all(10)
+        .dates
+        .into_iter()
+        .map(move |dtstart| DatePerhapsTime {
+            dt: dtstart.with_timezone(&params.tz),
+            all_day,
+        });
+    Ok(Some(dates))
+}
+
+fn recurring_dates(
+    params: &Parameters,
+    ev: &icalendar::Event,
+    rrule: &icalendar::Property,
+) -> Result<impl Iterator<Item = DatePerhapsTime>> {
+    Ok(recurring_dates_opt(params, ev, rrule)?
+        .into_iter()
+        .flatten())
+}
+
+fn google_url(
+    dtstart: DatePerhapsTime,
+    has_rrule: bool,
+    uid: Option<&str>,
+    google_id: &str,
+) -> Result<Option<String>> {
+    let uid = uid.context("No UID")?;
+    if uid.len() > 100 {
+        // There's one event in one of our test Google calendars which originates from Microsoft Exchange and has a totally different UID format from any other event. I was not able to reverse it, so I'm skipping it for now.
+        return Ok(None);
+    }
+
+    // Strip off the back part of the Google UID
+    let idx = uid.find(['@', '_']).unwrap_or(uid.len());
+    let uid_2 = &uid[..idx];
+    let utc_dtstart = dtstart
+        .dt
+        .with_timezone(&chrono_tz::UTC)
+        .format("%Y%m%dT%H%M%SZ")
+        .to_string();
+    let eid_plain = if has_rrule {
+        // Recurring events have an extra timestamp in their base64 to disambiguiate
+        format!("{uid_2}_{utc_dtstart} {google_id}")
+    } else {
+        format!("{uid_2} {google_id}")
+    };
+    let eid = base64::engine::general_purpose::URL_SAFE_NO_PAD.encode(&eid_plain);
+    let mut link = url::Url::parse("https://www.google.com/calendar/event").unwrap();
+    link.query_pairs_mut().append_pair("eid", &eid);
+    Ok(Some(link.to_string()))
+}
+
+fn ical_event_instances(
+    config_ical: &Config,
+    params: &Parameters,
+    ev: &icalendar::Event,
+) -> Result<Vec<EventInstance>> {
+    let dates = if let Some(rrule) = ev.properties().get("RRULE") {
+        recurring_dates(params, ev, rrule)?.collect()
+    } else {
+        // Event that occurs once
+
+        let dtstart = ev.get_start().context("Data error - Event has no start")?;
+        let dtstart_normalized = normalize_date_perhaps_time(&dtstart, params.tz)?;
+        if dtstart_normalized.dt < params.output_start || dtstart_normalized.dt > params.output_stop
+        {
+            return Ok(vec![]);
+        }
+        vec![dtstart_normalized]
+    };
+
+    let instances = dates
+        .into_iter()
+        .map(|dtstart| {
+            let has_rrule = ev.properties().get("RRULE").is_some();
+            let uid = ev.get_uid().map(|s| s.to_string());
+            let url = if let Some(url) = ev.get_url() {
+                Some(url.to_string())
+            } else if let Some(google_id) = &config_ical.google_id {
+                google_url(dtstart, has_rrule, uid.as_deref(), google_id)?
+            } else {
+                None
+            };
+
+            Ok::<_, anyhow::Error>(EventInstance {
+                calendar_ui: config_ical.ui.clone(),
+                dtstart,
+                location: ev.get_location().map(|s| s.to_string()),
+                recurrence_id: ev.get_recurrence_id(),
+                summary: ev.get_summary().map(|s| s.to_string()),
+                uid,
+                url,
+            })
+        })
+        .collect();
+    instances
+}
+
+impl Calendar {
+    pub(crate) fn read_from_str(config: Config, s: &str) -> Result<Self> {
+        let cal = s.parse().map_err(|s| anyhow!("parse error {s}"))?;
+        let cal = Self { cal, config };
+        Ok(cal)
+    }
+
+    pub(crate) fn read_from_downloadable(config: Config) -> Result<Self> {
+        let s = std::fs::read_to_string(&config.dl.file_path)?;
+        Self::read_from_str(config, &s)
+    }
+
+    fn events(&self) -> impl Iterator<Item = &icalendar::Event> {
+        self.cal.components.iter().filter_map(|comp| {
+            if let icalendar::CalendarComponent::Event(ev) = comp {
+                Some(ev)
+            } else {
+                None
+            }
+        })
+    }
+
+    /// Returns an unsorted list of event instances for this calendar
+    pub(crate) fn event_instances(&self, params: &Parameters) -> Result<Vec<EventInstance>> {
+        let mut instances = vec![];
+        let mut recurrence_exceptions = BTreeSet::new();
+
+        for ev in self.events() {
+            let eis = match ical_event_instances(&self.config, params, ev)
+                .with_context(|| format!("Failed to process event with UID '{:?}'", ev.get_uid()))
+            {
+                Ok(x) => x,
+                Err(e) => {
+                    if ev.get_last_modified().context("Event has no timestamp")?
+                        < params.ignore_before
+                    {
+                        tracing::warn!("Ignoring error from very old event {e:?}");
+                        continue;
+                    } else {
+                        Err(e)?
+                    }
+                }
+            };
+            for ei in eis {
+                instances.push(ei);
+            }
+
+            if let Some(recurrence_id) = ev.get_recurrence_id() {
+                // This is a recurrence exception and we must handle it specially by later deleting the original event it replaces
+                let recurrence_id = normalize_date_perhaps_time(&recurrence_id, params.tz)
+                    .context("We should be able to normalize recurrence IDs")?;
+                let uid = ev
+                    .get_uid()
+                    .context("Every recurrence exception should have a UID")?;
+
+                recurrence_exceptions.insert(RecurrenceKey { recurrence_id, uid });
+            }
+        }
+
+        // Find all recurring events that are replaced with recurrence exceptions and delete the originals.
+        // There is probably a not-linear-time way to do this, but this should be fine.
+
+        instances.retain(|ev| {
+            if ev.recurrence_id.is_some() {
+                // This is a recurrence exception, exceptions never delete themselves
+                return true;
+            }
+
+            let Some(uid) = &ev.uid else {
+                // If there's no UID, we can't apply recurrence exceptions
+                return true;
+            };
+            let key = RecurrenceKey {
+                recurrence_id: ev.dtstart,
+                uid,
+            };
+            !recurrence_exceptions.contains(&key)
+        });
+
+        Ok(instances)
+    }
+}