aerogramme/src/dav/calencoder.rs

498 lines
18 KiB
Rust
Raw Normal View History

2024-02-29 19:40:40 +00:00
use super::encoder::{QuickWritable, Context};
use super::caltypes::*;
use super::types::Extension;
use quick_xml::Error as QError;
use quick_xml::events::{Event, BytesEnd, BytesStart, BytesText};
use quick_xml::writer::{ElementWriter, Writer};
use quick_xml::name::PrefixDeclaration;
use tokio::io::AsyncWrite;
2024-03-02 17:19:03 +00:00
const ICAL_DATETIME_FMT: &str = "%Y%m%dT%H%M%SZ";
2024-03-02 15:52:52 +00:00
// =============== Calendar Trait ===========================
pub trait CalContext: Context {
fn create_cal_element(&self, name: &str) -> BytesStart;
}
// =============== CalDAV Extension Setup ===================
2024-03-01 07:32:02 +00:00
impl Context for CalExtension {
2024-02-29 19:40:40 +00:00
fn child(&self) -> Self {
Self { root: false }
}
fn create_dav_element(&self, name: &str) -> BytesStart {
2024-02-29 21:32:07 +00:00
self.create_ns_element("D", name)
}
async fn hook_error(&self, err: &Violation, xml: &mut Writer<impl AsyncWrite+Unpin>) -> Result<(), QError> {
err.write(xml, self.child()).await
}
2024-03-01 09:12:19 +00:00
async fn hook_property(&self, prop: &Self::Property, xml: &mut Writer<impl AsyncWrite+Unpin>) -> Result<(), QError> {
prop.write(xml, self.child()).await
}
2024-03-01 09:29:16 +00:00
async fn hook_resourcetype(&self, restype: &Self::ResourceType, xml: &mut Writer<impl AsyncWrite+Unpin>) -> Result<(), QError> {
restype.write(xml, self.child()).await
}
2024-03-01 13:28:36 +00:00
async fn hook_propertyrequest(&self, propreq: &Self::PropertyRequest, xml: &mut Writer<impl AsyncWrite+Unpin>) -> Result<(), QError> {
propreq.write(xml, self.child()).await
}
2024-02-29 21:32:07 +00:00
}
2024-03-01 07:32:02 +00:00
2024-03-02 15:52:52 +00:00
impl CalContext for CalExtension {
fn create_cal_element(&self, name: &str) -> BytesStart {
self.create_ns_element("C", name)
}
}
2024-03-01 07:32:02 +00:00
impl CalExtension {
2024-02-29 21:32:07 +00:00
fn create_ns_element(&self, ns: &str, name: &str) -> BytesStart {
let mut start = BytesStart::new(format!("{}:{}", ns, name));
2024-02-29 19:40:40 +00:00
if self.root {
start.push_attribute(("xmlns:D", "DAV:"));
start.push_attribute(("xmlns:C", "urn:ietf:params:xml:ns:caldav"));
}
start
}
2024-03-02 15:52:52 +00:00
}
// ==================== Calendar Types Serialization =========================
// -------------------- MKCALENDAR METHOD ------------------------------------
impl<C: CalContext> QuickWritable<C> for MkCalendar<C> {
async fn write(&self, xml: &mut Writer<impl AsyncWrite+Unpin>, ctx: C) -> Result<(), QError> {
2024-03-02 17:19:03 +00:00
let start = ctx.create_cal_element("mkcalendar");
let end = start.to_end();
xml.write_event_async(Event::Start(start.clone())).await?;
self.0.write(xml, ctx.child()).await?;
xml.write_event_async(Event::End(end)).await
2024-03-02 15:52:52 +00:00
}
}
impl<C: CalContext> QuickWritable<C> for MkCalendarResponse<C> {
async fn write(&self, xml: &mut Writer<impl AsyncWrite+Unpin>, ctx: C) -> Result<(), QError> {
2024-03-02 17:19:03 +00:00
let start = ctx.create_cal_element("mkcalendar-response");
let end = start.to_end();
xml.write_event_async(Event::Start(start.clone())).await?;
for propstat in self.0.iter() {
propstat.write(xml, ctx.child()).await?;
}
xml.write_event_async(Event::End(end)).await
2024-03-02 15:52:52 +00:00
}
}
// ----------------------- REPORT METHOD -------------------------------------
impl<C: CalContext> QuickWritable<C> for CalendarQuery<C> {
async fn write(&self, xml: &mut Writer<impl AsyncWrite+Unpin>, ctx: C) -> Result<(), QError> {
2024-03-02 17:19:03 +00:00
let start = ctx.create_cal_element("calendar-query");
let end = start.to_end();
xml.write_event_async(Event::Start(start.clone())).await?;
if let Some(selector) = &self.selector {
selector.write(xml, ctx.child()).await?;
}
self.filter.write(xml, ctx.child()).await?;
if let Some(tz) = &self.timezone {
tz.write(xml, ctx.child()).await?;
}
xml.write_event_async(Event::End(end)).await
2024-03-02 15:52:52 +00:00
}
}
impl<C: CalContext> QuickWritable<C> for CalendarMultiget<C> {
async fn write(&self, xml: &mut Writer<impl AsyncWrite+Unpin>, ctx: C) -> Result<(), QError> {
2024-03-02 17:19:03 +00:00
let start = ctx.create_cal_element("calendar-multiget");
let end = start.to_end();
xml.write_event_async(Event::Start(start.clone())).await?;
if let Some(selector) = &self.selector {
selector.write(xml, ctx.child()).await?;
}
for href in self.href.iter() {
href.write(xml, ctx.child()).await?;
}
xml.write_event_async(Event::End(end)).await
2024-03-02 15:52:52 +00:00
}
}
impl<C: CalContext> QuickWritable<C> for FreeBusyQuery {
async fn write(&self, xml: &mut Writer<impl AsyncWrite+Unpin>, ctx: C) -> Result<(), QError> {
2024-03-02 17:19:03 +00:00
let start = ctx.create_cal_element("free-busy-query");
let end = start.to_end();
xml.write_event_async(Event::Start(start.clone())).await?;
self.0.write(xml, ctx.child()).await?;
xml.write_event_async(Event::End(end)).await
2024-03-02 15:52:52 +00:00
}
}
// -------------------------- DAV::prop --------------------------------------
2024-03-02 17:19:03 +00:00
impl<C: CalContext> QuickWritable<C> for PropertyRequest {
2024-03-02 15:52:52 +00:00
async fn write(&self, xml: &mut Writer<impl AsyncWrite+Unpin>, ctx: C) -> Result<(), QError> {
2024-03-02 17:19:03 +00:00
let mut atom = async |c| xml.write_event_async(Event::Empty(ctx.create_cal_element(c))).await;
match self {
Self::CalendarDescription => atom("calendar-description").await,
Self::CalendarTimezone => atom("calendar-timezone").await,
Self::SupportedCalendarComponentSet => atom("supported-calendar-component-set").await,
Self::SupportedCalendarData => atom("supported-calendar-data").await,
Self::MaxResourceSize => atom("max-resource-size").await,
Self::MinDateTime => atom("min-date-time").await,
Self::MaxDateTime => atom("max-date-time").await,
Self::MaxInstances => atom("max-instances").await,
Self::MaxAttendeesPerInstance => atom("max-attendees-per-instance").await,
Self::SupportedCollationSet => atom("supported-collation-set").await,
Self::CalendarData(req) => req.write(xml, ctx).await,
}
2024-03-02 15:52:52 +00:00
}
}
2024-03-02 17:19:03 +00:00
impl<C: CalContext> QuickWritable<C> for Property {
2024-03-02 15:52:52 +00:00
async fn write(&self, xml: &mut Writer<impl AsyncWrite+Unpin>, ctx: C) -> Result<(), QError> {
2024-03-02 17:19:03 +00:00
match self {
Self::CalendarDescription { lang, text } => {
let mut start = ctx.create_cal_element("calendar-description");
if let Some(the_lang) = lang {
start.push_attribute(("xml:lang", the_lang.as_str()));
}
let end = start.to_end();
xml.write_event_async(Event::Start(start.clone())).await?;
xml.write_event_async(Event::Text(BytesText::new(text))).await?;
xml.write_event_async(Event::End(end)).await
},
Self::CalendarTimezone(payload) => {
let start = ctx.create_cal_element("calendar-timezone");
let end = start.to_end();
xml.write_event_async(Event::Start(start.clone())).await?;
xml.write_event_async(Event::Text(BytesText::new(payload))).await?;
xml.write_event_async(Event::End(end)).await
},
Self::SupportedCalendarComponentSet(many_comp) => {
let start = ctx.create_cal_element("supported-calendar-component-set");
let end = start.to_end();
xml.write_event_async(Event::Start(start.clone())).await?;
for comp in many_comp.iter() {
comp.write(xml, ctx.child()).await?;
}
xml.write_event_async(Event::End(end)).await
},
Self::SupportedCalendarData(many_mime) => {
let start = ctx.create_cal_element("supported-calendar-data");
let end = start.to_end();
xml.write_event_async(Event::Start(start.clone())).await?;
for mime in many_mime.iter() {
mime.write(xml, ctx.child()).await?;
}
xml.write_event_async(Event::End(end)).await
},
Self::MaxResourceSize(bytes) => {
let start = ctx.create_cal_element("max-resource-size");
let end = start.to_end();
xml.write_event_async(Event::Start(start.clone())).await?;
xml.write_event_async(Event::Text(BytesText::new(bytes.to_string().as_str()))).await?;
xml.write_event_async(Event::End(end)).await
},
Self::MinDateTime(dt) => {
let start = ctx.create_cal_element("min-date-time");
let end = start.to_end();
let dtstr = format!("{}", dt.format(ICAL_DATETIME_FMT));
xml.write_event_async(Event::Start(start.clone())).await?;
xml.write_event_async(Event::Text(BytesText::new(dtstr.as_str()))).await?;
xml.write_event_async(Event::End(end)).await
},
Self::MaxDateTime(dt) => {
let start = ctx.create_cal_element("max-date-time");
let end = start.to_end();
let dtstr = format!("{}", dt.format(ICAL_DATETIME_FMT));
xml.write_event_async(Event::Start(start.clone())).await?;
xml.write_event_async(Event::Text(BytesText::new(dtstr.as_str()))).await?;
xml.write_event_async(Event::End(end)).await
},
Self::MaxInstances(count) => {
let start = ctx.create_cal_element("max-instances");
let end = start.to_end();
xml.write_event_async(Event::Start(start.clone())).await?;
xml.write_event_async(Event::Text(BytesText::new(count.to_string().as_str()))).await?;
xml.write_event_async(Event::End(end)).await
},
Self::MaxAttendeesPerInstance(count) => {
let start = ctx.create_cal_element("max-attendees-per-instance");
let end = start.to_end();
xml.write_event_async(Event::Start(start.clone())).await?;
xml.write_event_async(Event::Text(BytesText::new(count.to_string().as_str()))).await?;
xml.write_event_async(Event::End(end)).await
},
Self::SupportedCollationSet(many_collations) => {
let start = ctx.create_cal_element("supported-collation-set");
let end = start.to_end();
xml.write_event_async(Event::Start(start.clone())).await?;
for collation in many_collations.iter() {
collation.write(xml, ctx.child()).await?;
}
xml.write_event_async(Event::End(end)).await
},
Self::CalendarData(inner) => inner.write(xml, ctx).await,
}
2024-03-02 15:52:52 +00:00
}
}
// ---------------------- DAV::resourcetype ----------------------------------
impl<C: CalContext> QuickWritable<C> for ResourceType {
async fn write(&self, xml: &mut Writer<impl AsyncWrite+Unpin>, ctx: C) -> Result<(), QError> {
match self {
Self::Calendar => xml.write_event_async(Event::Empty(ctx.create_dav_element("calendar"))).await,
}
2024-02-29 19:40:40 +00:00
}
}
2024-03-02 15:52:52 +00:00
// --------------------------- DAV::error ------------------------------------
impl<C: CalContext> QuickWritable<C> for Violation {
async fn write(&self, xml: &mut Writer<impl AsyncWrite+Unpin>, ctx: C) -> Result<(), QError> {
2024-02-29 19:40:40 +00:00
match self {
2024-03-02 09:08:51 +00:00
Self::ResourceMustBeNull => {
let start = ctx.create_cal_element("resource-must-be-null");
2024-02-29 21:32:07 +00:00
xml.write_event_async(Event::Empty(start)).await?;
},
2024-03-02 09:08:51 +00:00
_ => unimplemented!(),
2024-02-29 19:40:40 +00:00
};
Ok(())
}
}
2024-03-01 09:12:19 +00:00
2024-03-02 15:52:52 +00:00
// ---------------------------- Inner XML ------------------------------------
impl<C: CalContext> QuickWritable<C> for SupportedCollation {
async fn write(&self, xml: &mut Writer<impl AsyncWrite+Unpin>, ctx: C) -> Result<(), QError> {
2024-03-01 09:12:19 +00:00
unimplemented!();
}
}
2024-03-02 15:52:52 +00:00
impl<C: CalContext> QuickWritable<C> for Collation {
async fn write(&self, xml: &mut Writer<impl AsyncWrite+Unpin>, ctx: C) -> Result<(), QError> {
2024-03-01 13:28:36 +00:00
unimplemented!();
}
}
2024-03-02 15:52:52 +00:00
impl<C: CalContext> QuickWritable<C> for CalendarDataPayload {
async fn write(&self, xml: &mut Writer<impl AsyncWrite+Unpin>, ctx: C) -> Result<(), QError> {
unimplemented!();
}
}
impl<C: CalContext> QuickWritable<C> for CalendarDataRequest {
async fn write(&self, xml: &mut Writer<impl AsyncWrite+Unpin>, ctx: C) -> Result<(), QError> {
unimplemented!();
}
}
impl<C: CalContext> QuickWritable<C> for CalendarDataEmpty {
async fn write(&self, xml: &mut Writer<impl AsyncWrite+Unpin>, ctx: C) -> Result<(), QError> {
unimplemented!();
}
}
impl<C: CalContext> QuickWritable<C> for CalendarDataSupport {
async fn write(&self, xml: &mut Writer<impl AsyncWrite+Unpin>, ctx: C) -> Result<(), QError> {
unimplemented!();
}
}
impl<C: CalContext> QuickWritable<C> for Comp {
async fn write(&self, xml: &mut Writer<impl AsyncWrite+Unpin>, ctx: C) -> Result<(), QError> {
unimplemented!();
}
}
impl<C: CalContext> QuickWritable<C> for CompSupport {
async fn write(&self, xml: &mut Writer<impl AsyncWrite+Unpin>, ctx: C) -> Result<(), QError> {
unimplemented!();
}
}
impl<C: CalContext> QuickWritable<C> for CompKind {
async fn write(&self, xml: &mut Writer<impl AsyncWrite+Unpin>, ctx: C) -> Result<(), QError> {
unimplemented!();
}
}
impl<C: CalContext> QuickWritable<C> for PropKind {
async fn write(&self, xml: &mut Writer<impl AsyncWrite+Unpin>, ctx: C) -> Result<(), QError> {
unimplemented!();
}
}
impl<C: CalContext> QuickWritable<C> for CalProp {
async fn write(&self, xml: &mut Writer<impl AsyncWrite+Unpin>, ctx: C) -> Result<(), QError> {
unimplemented!();
}
}
impl<C: CalContext> QuickWritable<C> for RecurrenceModifier {
async fn write(&self, xml: &mut Writer<impl AsyncWrite+Unpin>, ctx: C) -> Result<(), QError> {
unimplemented!();
}
}
impl<C: CalContext> QuickWritable<C> for Expand {
async fn write(&self, xml: &mut Writer<impl AsyncWrite+Unpin>, ctx: C) -> Result<(), QError> {
unimplemented!();
}
}
impl<C: CalContext> QuickWritable<C> for LimitRecurrenceSet {
async fn write(&self, xml: &mut Writer<impl AsyncWrite+Unpin>, ctx: C) -> Result<(), QError> {
unimplemented!();
}
}
impl<C: CalContext> QuickWritable<C> for LimitFreebusySet {
async fn write(&self, xml: &mut Writer<impl AsyncWrite+Unpin>, ctx: C) -> Result<(), QError> {
unimplemented!();
}
}
impl<C: CalContext> QuickWritable<C> for CalendarSelector<C> {
async fn write(&self, xml: &mut Writer<impl AsyncWrite+Unpin>, ctx: C) -> Result<(), QError> {
unimplemented!();
}
}
impl<C: CalContext> QuickWritable<C> for CompFilter {
async fn write(&self, xml: &mut Writer<impl AsyncWrite+Unpin>, ctx: C) -> Result<(), QError> {
unimplemented!();
}
}
impl<C: CalContext> QuickWritable<C> for CompFilterInner {
async fn write(&self, xml: &mut Writer<impl AsyncWrite+Unpin>, ctx: C) -> Result<(), QError> {
unimplemented!();
}
}
impl<C: CalContext> QuickWritable<C> for CompFilterMatch {
async fn write(&self, xml: &mut Writer<impl AsyncWrite+Unpin>, ctx: C) -> Result<(), QError> {
unimplemented!();
}
}
impl<C: CalContext> QuickWritable<C> for PropFilter {
async fn write(&self, xml: &mut Writer<impl AsyncWrite+Unpin>, ctx: C) -> Result<(), QError> {
unimplemented!();
}
}
impl<C: CalContext> QuickWritable<C> for PropFilterInner {
async fn write(&self, xml: &mut Writer<impl AsyncWrite+Unpin>, ctx: C) -> Result<(), QError> {
unimplemented!();
}
}
impl<C: CalContext> QuickWritable<C> for PropFilterMatch {
async fn write(&self, xml: &mut Writer<impl AsyncWrite+Unpin>, ctx: C) -> Result<(), QError> {
unimplemented!();
2024-03-01 09:29:16 +00:00
}
}
2024-02-29 19:40:40 +00:00
2024-03-02 15:52:52 +00:00
impl<C: CalContext> QuickWritable<C> for TimeOrText {
async fn write(&self, xml: &mut Writer<impl AsyncWrite+Unpin>, ctx: C) -> Result<(), QError> {
unimplemented!();
}
}
impl<C: CalContext> QuickWritable<C> for TextMatch {
async fn write(&self, xml: &mut Writer<impl AsyncWrite+Unpin>, ctx: C) -> Result<(), QError> {
unimplemented!();
}
}
impl<C: CalContext> QuickWritable<C> for ParamFilter {
async fn write(&self, xml: &mut Writer<impl AsyncWrite+Unpin>, ctx: C) -> Result<(), QError> {
unimplemented!();
}
}
impl<C: CalContext> QuickWritable<C> for ParamFilterMatch {
async fn write(&self, xml: &mut Writer<impl AsyncWrite+Unpin>, ctx: C) -> Result<(), QError> {
unimplemented!();
}
}
impl<C: CalContext> QuickWritable<C> for TimeZone {
async fn write(&self, xml: &mut Writer<impl AsyncWrite+Unpin>, ctx: C) -> Result<(), QError> {
unimplemented!();
}
}
impl<C: CalContext> QuickWritable<C> for Filter {
async fn write(&self, xml: &mut Writer<impl AsyncWrite+Unpin>, ctx: C) -> Result<(), QError> {
unimplemented!();
}
}
impl<C: CalContext> QuickWritable<C> for Component {
async fn write(&self, xml: &mut Writer<impl AsyncWrite+Unpin>, ctx: C) -> Result<(), QError> {
unimplemented!();
}
}
impl<C: CalContext> QuickWritable<C> for ComponentProperty {
async fn write(&self, xml: &mut Writer<impl AsyncWrite+Unpin>, ctx: C) -> Result<(), QError> {
unimplemented!();
}
}
impl<C: CalContext> QuickWritable<C> for PropertyParameter {
async fn write(&self, xml: &mut Writer<impl AsyncWrite+Unpin>, ctx: C) -> Result<(), QError> {
unimplemented!();
}
}
impl<C: CalContext> QuickWritable<C> for TimeRange {
async fn write(&self, xml: &mut Writer<impl AsyncWrite+Unpin>, ctx: C) -> Result<(), QError> {
unimplemented!();
}
}
2024-02-29 19:40:40 +00:00
#[cfg(test)]
mod tests {
use super::*;
use crate::dav::types::{Error, Violation as DavViolation};
use tokio::io::AsyncWriteExt;
#[tokio::test]
async fn test_violation() {
let mut buffer = Vec::new();
let mut tokio_buffer = tokio::io::BufWriter::new(&mut buffer);
let mut writer = Writer::new_with_indent(&mut tokio_buffer, b' ', 4);
2024-03-01 07:32:02 +00:00
let res = Error(vec![
2024-03-02 09:08:51 +00:00
DavViolation::Extension(Violation::ResourceMustBeNull),
2024-02-29 19:40:40 +00:00
]);
2024-03-01 07:32:02 +00:00
res.write(&mut writer, CalExtension { root: true }).await.expect("xml serialization");
2024-02-29 19:40:40 +00:00
tokio_buffer.flush().await.expect("tokio buffer flush");
let expected = r#"<D:error xmlns:D="DAV:" xmlns:C="urn:ietf:params:xml:ns:caldav">
2024-03-02 09:08:51 +00:00
<C:resource-must-be-null/>
2024-02-29 19:40:40 +00:00
</D:error>"#;
let got = std::str::from_utf8(buffer.as_slice()).unwrap();
assert_eq!(got, expected);
}
}