aerogramme/aero-dav/src/calencoder.rs

1018 lines
40 KiB
Rust
Raw Normal View History

2024-05-16 15:38:34 +00:00
use quick_xml::events::{BytesText, Event};
2024-02-29 19:40:40 +00:00
use quick_xml::Error as QError;
2024-03-05 17:02:43 +00:00
use super::caltypes::*;
2024-03-06 22:24:54 +00:00
use super::types::Extension;
2024-05-16 15:38:34 +00:00
use super::xml::{IWrite, Node, QWrite, Writer};
2024-03-02 15:52:52 +00:00
// ==================== Calendar Types Serialization =========================
// -------------------- MKCALENDAR METHOD ------------------------------------
2024-03-05 17:02:43 +00:00
impl<E: Extension> QWrite for MkCalendar<E> {
async fn qwrite(&self, xml: &mut Writer<impl IWrite>) -> Result<(), QError> {
let start = xml.create_cal_element("mkcalendar");
2024-03-02 17:19:03 +00:00
let end = start.to_end();
2024-03-05 17:02:43 +00:00
xml.q.write_event_async(Event::Start(start.clone())).await?;
self.0.qwrite(xml).await?;
xml.q.write_event_async(Event::End(end)).await
2024-03-02 15:52:52 +00:00
}
}
2024-03-18 19:45:30 +00:00
impl<E: Extension> QWrite for MkCalendarResponse<E> {
2024-03-05 17:02:43 +00:00
async fn qwrite(&self, xml: &mut Writer<impl IWrite>) -> Result<(), QError> {
let start = xml.create_cal_element("mkcalendar-response");
2024-03-02 17:19:03 +00:00
let end = start.to_end();
2024-03-05 17:02:43 +00:00
xml.q.write_event_async(Event::Start(start.clone())).await?;
2024-03-02 17:19:03 +00:00
for propstat in self.0.iter() {
2024-03-05 17:02:43 +00:00
propstat.qwrite(xml).await?;
2024-03-02 17:19:03 +00:00
}
2024-03-05 17:02:43 +00:00
xml.q.write_event_async(Event::End(end)).await
2024-03-02 15:52:52 +00:00
}
}
// ----------------------- REPORT METHOD -------------------------------------
impl<E: Extension> QWrite for Report<E> {
async fn qwrite(&self, xml: &mut Writer<impl IWrite>) -> Result<(), QError> {
match self {
Self::Query(v) => v.qwrite(xml).await,
Self::Multiget(v) => v.qwrite(xml).await,
Self::FreeBusy(v) => v.qwrite(xml).await,
}
}
}
2024-03-02 15:52:52 +00:00
2024-03-05 17:02:43 +00:00
impl<E: Extension> QWrite for CalendarQuery<E> {
async fn qwrite(&self, xml: &mut Writer<impl IWrite>) -> Result<(), QError> {
let start = xml.create_cal_element("calendar-query");
2024-03-02 17:19:03 +00:00
let end = start.to_end();
2024-03-05 17:02:43 +00:00
xml.q.write_event_async(Event::Start(start.clone())).await?;
2024-03-02 17:19:03 +00:00
if let Some(selector) = &self.selector {
2024-03-05 17:02:43 +00:00
selector.qwrite(xml).await?;
2024-03-02 17:19:03 +00:00
}
2024-03-05 17:02:43 +00:00
self.filter.qwrite(xml).await?;
2024-05-16 15:38:34 +00:00
if let Some(tz) = &self.timezone {
2024-03-05 17:02:43 +00:00
tz.qwrite(xml).await?;
2024-03-02 17:19:03 +00:00
}
2024-03-05 17:02:43 +00:00
xml.q.write_event_async(Event::End(end)).await
2024-03-02 15:52:52 +00:00
}
}
2024-03-05 17:02:43 +00:00
impl<E: Extension> QWrite for CalendarMultiget<E> {
async fn qwrite(&self, xml: &mut Writer<impl IWrite>) -> Result<(), QError> {
let start = xml.create_cal_element("calendar-multiget");
2024-03-02 17:19:03 +00:00
let end = start.to_end();
2024-03-05 17:02:43 +00:00
xml.q.write_event_async(Event::Start(start.clone())).await?;
2024-03-02 17:19:03 +00:00
if let Some(selector) = &self.selector {
2024-03-05 17:02:43 +00:00
selector.qwrite(xml).await?;
2024-03-02 17:19:03 +00:00
}
for href in self.href.iter() {
2024-03-05 17:02:43 +00:00
href.qwrite(xml).await?;
2024-03-02 17:19:03 +00:00
}
2024-03-05 17:02:43 +00:00
xml.q.write_event_async(Event::End(end)).await
2024-03-02 15:52:52 +00:00
}
}
2024-03-05 17:02:43 +00:00
impl QWrite for FreeBusyQuery {
async fn qwrite(&self, xml: &mut Writer<impl IWrite>) -> Result<(), QError> {
let start = xml.create_cal_element("free-busy-query");
2024-03-02 17:19:03 +00:00
let end = start.to_end();
2024-03-05 17:02:43 +00:00
xml.q.write_event_async(Event::Start(start.clone())).await?;
self.0.qwrite(xml).await?;
xml.q.write_event_async(Event::End(end)).await
2024-03-02 15:52:52 +00:00
}
}
// -------------------------- DAV::prop --------------------------------------
2024-03-05 17:02:43 +00:00
impl QWrite for PropertyRequest {
async fn qwrite(&self, xml: &mut Writer<impl IWrite>) -> Result<(), QError> {
let mut atom = async |c| {
let empty_tag = xml.create_cal_element(c);
xml.q.write_event_async(Event::Empty(empty_tag)).await
};
2024-03-02 17:19:03 +00:00
match self {
2024-03-18 21:56:49 +00:00
Self::CalendarHomeSet => atom("calendar-home-set").await,
2024-03-02 17:19:03 +00:00
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,
2024-05-16 15:38:34 +00:00
Self::MaxAttendeesPerInstance => atom("max-attendees-per-instance").await,
Self::SupportedCollationSet => atom("supported-collation-set").await,
2024-03-05 17:02:43 +00:00
Self::CalendarData(req) => req.qwrite(xml).await,
2024-03-02 17:19:03 +00:00
}
2024-03-02 15:52:52 +00:00
}
}
2024-03-05 17:02:43 +00:00
impl QWrite for Property {
async fn qwrite(&self, xml: &mut Writer<impl IWrite>) -> Result<(), QError> {
2024-03-02 17:19:03 +00:00
match self {
2024-03-18 21:56:49 +00:00
Self::CalendarHomeSet(href) => {
let start = xml.create_cal_element("calendar-home-set");
let end = start.to_end();
xml.q.write_event_async(Event::Start(start.clone())).await?;
href.qwrite(xml).await?;
xml.q.write_event_async(Event::End(end)).await
}
2024-03-02 17:19:03 +00:00
Self::CalendarDescription { lang, text } => {
2024-03-05 17:02:43 +00:00
let mut start = xml.create_cal_element("calendar-description");
2024-03-02 17:19:03 +00:00
if let Some(the_lang) = lang {
start.push_attribute(("xml:lang", the_lang.as_str()));
}
let end = start.to_end();
2024-03-05 17:02:43 +00:00
xml.q.write_event_async(Event::Start(start.clone())).await?;
2024-05-16 15:38:34 +00:00
xml.q
.write_event_async(Event::Text(BytesText::new(text)))
.await?;
2024-03-05 17:02:43 +00:00
xml.q.write_event_async(Event::End(end)).await
2024-05-16 15:38:34 +00:00
}
2024-03-02 17:19:03 +00:00
Self::CalendarTimezone(payload) => {
2024-03-05 17:02:43 +00:00
let start = xml.create_cal_element("calendar-timezone");
2024-03-02 17:19:03 +00:00
let end = start.to_end();
2024-03-05 17:02:43 +00:00
xml.q.write_event_async(Event::Start(start.clone())).await?;
2024-05-16 15:38:34 +00:00
xml.q
.write_event_async(Event::Text(BytesText::new(payload)))
.await?;
2024-03-05 17:02:43 +00:00
xml.q.write_event_async(Event::End(end)).await
2024-05-16 15:38:34 +00:00
}
2024-03-02 17:19:03 +00:00
Self::SupportedCalendarComponentSet(many_comp) => {
2024-03-05 17:02:43 +00:00
let start = xml.create_cal_element("supported-calendar-component-set");
2024-03-02 17:19:03 +00:00
let end = start.to_end();
2024-03-05 17:02:43 +00:00
xml.q.write_event_async(Event::Start(start.clone())).await?;
2024-03-02 17:19:03 +00:00
for comp in many_comp.iter() {
2024-03-05 17:02:43 +00:00
comp.qwrite(xml).await?;
2024-03-02 17:19:03 +00:00
}
2024-03-05 17:02:43 +00:00
xml.q.write_event_async(Event::End(end)).await
2024-05-16 15:38:34 +00:00
}
2024-03-02 17:19:03 +00:00
Self::SupportedCalendarData(many_mime) => {
2024-03-05 17:02:43 +00:00
let start = xml.create_cal_element("supported-calendar-data");
2024-03-02 17:19:03 +00:00
let end = start.to_end();
2024-03-05 17:02:43 +00:00
xml.q.write_event_async(Event::Start(start.clone())).await?;
2024-03-02 17:19:03 +00:00
for mime in many_mime.iter() {
2024-03-05 17:02:43 +00:00
mime.qwrite(xml).await?;
2024-03-02 17:19:03 +00:00
}
2024-03-05 17:02:43 +00:00
xml.q.write_event_async(Event::End(end)).await
2024-05-16 15:38:34 +00:00
}
2024-03-02 17:19:03 +00:00
Self::MaxResourceSize(bytes) => {
2024-03-05 17:02:43 +00:00
let start = xml.create_cal_element("max-resource-size");
2024-03-02 17:19:03 +00:00
let end = start.to_end();
2024-03-05 17:02:43 +00:00
xml.q.write_event_async(Event::Start(start.clone())).await?;
2024-05-16 15:38:34 +00:00
xml.q
.write_event_async(Event::Text(BytesText::new(bytes.to_string().as_str())))
.await?;
2024-03-05 17:02:43 +00:00
xml.q.write_event_async(Event::End(end)).await
2024-05-16 15:38:34 +00:00
}
2024-03-02 17:19:03 +00:00
Self::MinDateTime(dt) => {
2024-03-05 17:02:43 +00:00
let start = xml.create_cal_element("min-date-time");
2024-03-02 17:19:03 +00:00
let end = start.to_end();
let dtstr = format!("{}", dt.format(ICAL_DATETIME_FMT));
2024-03-05 17:02:43 +00:00
xml.q.write_event_async(Event::Start(start.clone())).await?;
2024-05-16 15:38:34 +00:00
xml.q
.write_event_async(Event::Text(BytesText::new(dtstr.as_str())))
.await?;
2024-03-05 17:02:43 +00:00
xml.q.write_event_async(Event::End(end)).await
2024-05-16 15:38:34 +00:00
}
2024-03-02 17:19:03 +00:00
Self::MaxDateTime(dt) => {
2024-03-05 17:02:43 +00:00
let start = xml.create_cal_element("max-date-time");
2024-03-02 17:19:03 +00:00
let end = start.to_end();
let dtstr = format!("{}", dt.format(ICAL_DATETIME_FMT));
2024-03-05 17:02:43 +00:00
xml.q.write_event_async(Event::Start(start.clone())).await?;
2024-05-16 15:38:34 +00:00
xml.q
.write_event_async(Event::Text(BytesText::new(dtstr.as_str())))
.await?;
2024-03-05 17:02:43 +00:00
xml.q.write_event_async(Event::End(end)).await
2024-05-16 15:38:34 +00:00
}
2024-03-02 17:19:03 +00:00
Self::MaxInstances(count) => {
2024-03-05 17:02:43 +00:00
let start = xml.create_cal_element("max-instances");
2024-03-02 17:19:03 +00:00
let end = start.to_end();
2024-03-05 17:02:43 +00:00
xml.q.write_event_async(Event::Start(start.clone())).await?;
2024-05-16 15:38:34 +00:00
xml.q
.write_event_async(Event::Text(BytesText::new(count.to_string().as_str())))
.await?;
2024-03-05 17:02:43 +00:00
xml.q.write_event_async(Event::End(end)).await
2024-05-16 15:38:34 +00:00
}
2024-03-02 17:19:03 +00:00
Self::MaxAttendeesPerInstance(count) => {
2024-03-05 17:02:43 +00:00
let start = xml.create_cal_element("max-attendees-per-instance");
2024-03-02 17:19:03 +00:00
let end = start.to_end();
2024-03-05 17:02:43 +00:00
xml.q.write_event_async(Event::Start(start.clone())).await?;
2024-05-16 15:38:34 +00:00
xml.q
.write_event_async(Event::Text(BytesText::new(count.to_string().as_str())))
.await?;
2024-03-05 17:02:43 +00:00
xml.q.write_event_async(Event::End(end)).await
2024-05-16 15:38:34 +00:00
}
2024-03-02 17:19:03 +00:00
Self::SupportedCollationSet(many_collations) => {
2024-03-05 17:02:43 +00:00
let start = xml.create_cal_element("supported-collation-set");
2024-03-02 17:19:03 +00:00
let end = start.to_end();
2024-03-05 17:02:43 +00:00
xml.q.write_event_async(Event::Start(start.clone())).await?;
2024-03-02 17:19:03 +00:00
for collation in many_collations.iter() {
2024-03-05 17:02:43 +00:00
collation.qwrite(xml).await?;
2024-03-02 17:19:03 +00:00
}
2024-05-16 15:38:34 +00:00
xml.q.write_event_async(Event::End(end)).await
}
2024-03-05 17:02:43 +00:00
Self::CalendarData(inner) => inner.qwrite(xml).await,
2024-03-02 17:19:03 +00:00
}
2024-03-02 15:52:52 +00:00
}
}
// ---------------------- DAV::resourcetype ----------------------------------
2024-03-05 17:02:43 +00:00
impl QWrite for ResourceType {
async fn qwrite(&self, xml: &mut Writer<impl IWrite>) -> Result<(), QError> {
2024-03-02 15:52:52 +00:00
match self {
2024-03-05 17:02:43 +00:00
Self::Calendar => {
2024-03-18 14:04:46 +00:00
let empty_tag = xml.create_cal_element("calendar");
2024-03-05 17:02:43 +00:00
xml.q.write_event_async(Event::Empty(empty_tag)).await
2024-05-16 15:38:34 +00:00
}
2024-03-02 15:52:52 +00:00
}
2024-02-29 19:40:40 +00:00
}
}
2024-03-02 15:52:52 +00:00
// --------------------------- DAV::error ------------------------------------
2024-03-05 17:02:43 +00:00
impl QWrite for Violation {
async fn qwrite(&self, xml: &mut Writer<impl IWrite>) -> Result<(), QError> {
let mut atom = async |c| {
let empty_tag = xml.create_cal_element(c);
xml.q.write_event_async(Event::Empty(empty_tag)).await
};
2024-03-02 17:35:11 +00:00
2024-02-29 19:40:40 +00:00
match self {
2024-03-02 17:35:11 +00:00
//@FIXME
// DAV elements, should not be here but in RFC3744 on ACLs
// (we do not use atom as this error is in the DAV namespace, not the caldav one)
2024-03-05 17:02:43 +00:00
Self::NeedPrivileges => {
let empty_tag = xml.create_dav_element("need-privileges");
xml.q.write_event_async(Event::Empty(empty_tag)).await
2024-05-16 15:38:34 +00:00
}
2024-03-02 17:35:11 +00:00
// Regular CalDAV errors
Self::ResourceMustBeNull => atom("resource-must-be-null").await,
Self::CalendarCollectionLocationOk => atom("calendar-collection-location-ok").await,
Self::ValidCalendarData => atom("valid-calendar-data").await,
Self::InitializeCalendarCollection => atom("initialize-calendar-collection").await,
Self::SupportedCalendarData => atom("supported-calendar-data").await,
Self::ValidCalendarObjectResource => atom("valid-calendar-object-resource").await,
Self::SupportedCalendarComponent => atom("supported-calendar-component").await,
Self::NoUidConflict(href) => {
2024-03-05 17:02:43 +00:00
let start = xml.create_cal_element("no-uid-conflict");
2024-03-02 17:35:11 +00:00
let end = start.to_end();
2024-03-05 17:02:43 +00:00
xml.q.write_event_async(Event::Start(start.clone())).await?;
href.qwrite(xml).await?;
xml.q.write_event_async(Event::End(end)).await
2024-05-16 15:38:34 +00:00
}
2024-03-02 17:35:11 +00:00
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::ValidFilter => atom("valid-filter").await,
Self::SupportedFilter { comp, prop, param } => {
2024-03-05 17:02:43 +00:00
let start = xml.create_cal_element("supported-filter");
2024-03-02 17:35:11 +00:00
let end = start.to_end();
2024-03-05 17:02:43 +00:00
xml.q.write_event_async(Event::Start(start.clone())).await?;
2024-03-02 17:35:11 +00:00
for comp_item in comp.iter() {
2024-03-05 17:02:43 +00:00
comp_item.qwrite(xml).await?;
2024-03-02 17:35:11 +00:00
}
for prop_item in prop.iter() {
2024-03-05 17:02:43 +00:00
prop_item.qwrite(xml).await?;
2024-03-02 17:35:11 +00:00
}
for param_item in param.iter() {
2024-03-05 17:02:43 +00:00
param_item.qwrite(xml).await?;
2024-03-02 17:35:11 +00:00
}
2024-03-05 17:02:43 +00:00
xml.q.write_event_async(Event::End(end)).await
2024-05-16 15:38:34 +00:00
}
2024-03-02 17:35:11 +00:00
Self::NumberOfMatchesWithinLimits => atom("number-of-matches-within-limits").await,
}
2024-02-29 19:40:40 +00:00
}
}
2024-03-02 15:52:52 +00:00
// ---------------------------- Inner XML ------------------------------------
2024-03-05 17:02:43 +00:00
impl QWrite for SupportedCollation {
async fn qwrite(&self, xml: &mut Writer<impl IWrite>) -> Result<(), QError> {
let start = xml.create_cal_element("supported-collation");
2024-03-02 18:01:20 +00:00
let end = start.to_end();
2024-03-05 17:02:43 +00:00
xml.q.write_event_async(Event::Start(start.clone())).await?;
self.0.qwrite(xml).await?;
xml.q.write_event_async(Event::End(end)).await
2024-03-01 09:12:19 +00:00
}
}
2024-03-05 17:02:43 +00:00
impl QWrite for Collation {
async fn qwrite(&self, xml: &mut Writer<impl IWrite>) -> Result<(), QError> {
2024-03-02 18:01:20 +00:00
let col = match self {
2024-05-16 15:38:34 +00:00
Self::AsciiCaseMap => "i;ascii-casemap",
Self::Octet => "i;octet",
Self::Unknown(v) => v.as_str(),
2024-03-02 18:01:20 +00:00
};
2024-05-16 15:38:34 +00:00
xml.q
.write_event_async(Event::Text(BytesText::new(col)))
.await
2024-03-01 13:28:36 +00:00
}
}
2024-03-08 17:23:23 +00:00
impl QWrite for CalendarDataSupport {
async fn qwrite(&self, _xml: &mut Writer<impl IWrite>) -> Result<(), QError> {
unreachable!();
}
}
2024-03-05 17:02:43 +00:00
impl QWrite for CalendarDataPayload {
async fn qwrite(&self, xml: &mut Writer<impl IWrite>) -> Result<(), QError> {
let mut start = xml.create_cal_element("calendar-data");
2024-03-02 18:01:20 +00:00
if let Some(mime) = &self.mime {
start.push_attribute(("content-type", mime.content_type.as_str()));
start.push_attribute(("version", mime.version.as_str()));
}
let end = start.to_end();
2024-03-05 17:02:43 +00:00
xml.q.write_event_async(Event::Start(start.clone())).await?;
2024-05-16 15:38:34 +00:00
xml.q
.write_event_async(Event::Text(BytesText::new(self.payload.as_str())))
.await?;
2024-03-05 17:02:43 +00:00
xml.q.write_event_async(Event::End(end)).await
2024-03-02 15:52:52 +00:00
}
}
2024-03-05 17:02:43 +00:00
impl QWrite for CalendarDataRequest {
async fn qwrite(&self, xml: &mut Writer<impl IWrite>) -> Result<(), QError> {
let mut start = xml.create_cal_element("calendar-data");
2024-03-02 18:01:20 +00:00
if let Some(mime) = &self.mime {
start.push_attribute(("content-type", mime.content_type.as_str()));
start.push_attribute(("version", mime.version.as_str()));
}
// Empty tag
if self.comp.is_none() && self.recurrence.is_none() && self.limit_freebusy_set.is_none() {
2024-05-16 15:38:34 +00:00
return xml.q.write_event_async(Event::Empty(start.clone())).await;
}
2024-03-02 18:01:20 +00:00
let end = start.to_end();
2024-03-05 17:02:43 +00:00
xml.q.write_event_async(Event::Start(start.clone())).await?;
2024-03-02 18:01:20 +00:00
if let Some(comp) = &self.comp {
2024-03-05 17:02:43 +00:00
comp.qwrite(xml).await?;
2024-03-02 18:01:20 +00:00
}
if let Some(recurrence) = &self.recurrence {
2024-03-05 17:02:43 +00:00
recurrence.qwrite(xml).await?;
2024-03-02 18:01:20 +00:00
}
if let Some(freebusy) = &self.limit_freebusy_set {
2024-03-05 17:02:43 +00:00
freebusy.qwrite(xml).await?;
2024-03-02 18:01:20 +00:00
}
2024-03-05 17:02:43 +00:00
xml.q.write_event_async(Event::End(end)).await
2024-03-02 15:52:52 +00:00
}
}
2024-03-05 17:02:43 +00:00
impl QWrite for CalendarDataEmpty {
async fn qwrite(&self, xml: &mut Writer<impl IWrite>) -> Result<(), QError> {
let mut empty = xml.create_cal_element("calendar-data");
2024-03-02 18:01:20 +00:00
if let Some(mime) = &self.0 {
empty.push_attribute(("content-type", mime.content_type.as_str()));
empty.push_attribute(("version", mime.version.as_str()));
}
2024-03-05 17:02:43 +00:00
xml.q.write_event_async(Event::Empty(empty)).await
2024-03-02 15:52:52 +00:00
}
}
2024-03-05 17:02:43 +00:00
impl QWrite for Comp {
async fn qwrite(&self, xml: &mut Writer<impl IWrite>) -> Result<(), QError> {
let mut start = xml.create_cal_element("comp");
2024-03-02 22:01:56 +00:00
start.push_attribute(("name", self.name.as_str()));
2024-03-12 09:18:13 +00:00
match (&self.prop_kind, &self.comp_kind) {
(None, None) => xml.q.write_event_async(Event::Empty(start)).await,
_ => {
2024-03-04 08:02:24 +00:00
let end = start.to_end();
2024-03-05 17:02:43 +00:00
xml.q.write_event_async(Event::Start(start.clone())).await?;
2024-03-12 09:18:13 +00:00
if let Some(prop_kind) = &self.prop_kind {
prop_kind.qwrite(xml).await?;
}
if let Some(comp_kind) = &self.comp_kind {
comp_kind.qwrite(xml).await?;
}
2024-03-05 17:02:43 +00:00
xml.q.write_event_async(Event::End(end)).await
2024-05-16 15:38:34 +00:00
}
2024-03-04 08:02:24 +00:00
}
2024-03-02 15:52:52 +00:00
}
}
2024-03-05 17:02:43 +00:00
impl QWrite for CompSupport {
async fn qwrite(&self, xml: &mut Writer<impl IWrite>) -> Result<(), QError> {
let mut empty = xml.create_cal_element("comp");
2024-03-02 22:01:56 +00:00
empty.push_attribute(("name", self.0.as_str()));
2024-03-05 17:02:43 +00:00
xml.q.write_event_async(Event::Empty(empty)).await
2024-03-02 15:52:52 +00:00
}
}
2024-03-05 17:02:43 +00:00
impl QWrite for CompKind {
async fn qwrite(&self, xml: &mut Writer<impl IWrite>) -> Result<(), QError> {
2024-03-02 22:01:56 +00:00
match self {
2024-03-05 17:02:43 +00:00
Self::AllComp => {
let empty_tag = xml.create_cal_element("allcomp");
xml.q.write_event_async(Event::Empty(empty_tag)).await
2024-05-16 15:38:34 +00:00
}
2024-03-02 22:01:56 +00:00
Self::Comp(many_comp) => {
for comp in many_comp.iter() {
// Required: recursion in an async fn requires boxing
// rustc --explain E0733
2024-03-16 15:48:46 +00:00
// Cycle detected when computing type of ...
// For more information about this error, try `rustc --explain E0391`.
// https://github.com/rust-lang/rust/issues/78649
#[inline(always)]
2024-05-16 15:38:34 +00:00
fn recurse<'a>(
comp: &'a Comp,
xml: &'a mut Writer<impl IWrite>,
) -> futures::future::BoxFuture<'a, Result<(), QError>> {
2024-03-16 15:48:46 +00:00
Box::pin(comp.qwrite(xml))
}
recurse(comp, xml).await?;
2024-03-02 22:01:56 +00:00
}
Ok(())
}
}
2024-03-02 15:52:52 +00:00
}
}
2024-03-05 17:02:43 +00:00
impl QWrite for PropKind {
async fn qwrite(&self, xml: &mut Writer<impl IWrite>) -> Result<(), QError> {
2024-03-02 22:01:56 +00:00
match self {
2024-03-05 17:02:43 +00:00
Self::AllProp => {
let empty_tag = xml.create_cal_element("allprop");
xml.q.write_event_async(Event::Empty(empty_tag)).await
2024-05-16 15:38:34 +00:00
}
2024-03-02 22:01:56 +00:00
Self::Prop(many_prop) => {
for prop in many_prop.iter() {
2024-03-05 17:02:43 +00:00
prop.qwrite(xml).await?;
2024-03-02 22:01:56 +00:00
}
Ok(())
}
}
2024-03-02 15:52:52 +00:00
}
}
2024-03-05 17:02:43 +00:00
impl QWrite for CalProp {
async fn qwrite(&self, xml: &mut Writer<impl IWrite>) -> Result<(), QError> {
let mut empty = xml.create_cal_element("prop");
2024-03-02 22:01:56 +00:00
empty.push_attribute(("name", self.name.0.as_str()));
match self.novalue {
None => (),
Some(true) => empty.push_attribute(("novalue", "yes")),
Some(false) => empty.push_attribute(("novalue", "no")),
}
2024-03-05 17:02:43 +00:00
xml.q.write_event_async(Event::Empty(empty)).await
2024-03-02 15:52:52 +00:00
}
}
2024-03-05 17:02:43 +00:00
impl QWrite for RecurrenceModifier {
async fn qwrite(&self, xml: &mut Writer<impl IWrite>) -> Result<(), QError> {
2024-03-02 22:01:56 +00:00
match self {
2024-03-05 17:02:43 +00:00
Self::Expand(exp) => exp.qwrite(xml).await,
Self::LimitRecurrenceSet(lrs) => lrs.qwrite(xml).await,
2024-03-02 22:01:56 +00:00
}
2024-03-02 15:52:52 +00:00
}
}
2024-03-05 17:02:43 +00:00
impl QWrite for Expand {
async fn qwrite(&self, xml: &mut Writer<impl IWrite>) -> Result<(), QError> {
let mut empty = xml.create_cal_element("expand");
2024-05-16 15:38:34 +00:00
empty.push_attribute((
"start",
format!("{}", self.0.format(ICAL_DATETIME_FMT)).as_str(),
));
empty.push_attribute((
"end",
format!("{}", self.1.format(ICAL_DATETIME_FMT)).as_str(),
));
2024-03-05 17:02:43 +00:00
xml.q.write_event_async(Event::Empty(empty)).await
2024-03-02 15:52:52 +00:00
}
}
2024-03-05 17:02:43 +00:00
impl QWrite for LimitRecurrenceSet {
async fn qwrite(&self, xml: &mut Writer<impl IWrite>) -> Result<(), QError> {
let mut empty = xml.create_cal_element("limit-recurrence-set");
2024-05-16 15:38:34 +00:00
empty.push_attribute((
"start",
format!("{}", self.0.format(ICAL_DATETIME_FMT)).as_str(),
));
empty.push_attribute((
"end",
format!("{}", self.1.format(ICAL_DATETIME_FMT)).as_str(),
));
2024-03-05 17:02:43 +00:00
xml.q.write_event_async(Event::Empty(empty)).await
2024-03-02 15:52:52 +00:00
}
}
2024-03-05 17:02:43 +00:00
impl QWrite for LimitFreebusySet {
async fn qwrite(&self, xml: &mut Writer<impl IWrite>) -> Result<(), QError> {
let mut empty = xml.create_cal_element("limit-freebusy-set");
2024-05-16 15:38:34 +00:00
empty.push_attribute((
"start",
format!("{}", self.0.format(ICAL_DATETIME_FMT)).as_str(),
));
empty.push_attribute((
"end",
format!("{}", self.1.format(ICAL_DATETIME_FMT)).as_str(),
));
2024-03-05 17:02:43 +00:00
xml.q.write_event_async(Event::Empty(empty)).await
2024-03-02 15:52:52 +00:00
}
}
2024-03-05 17:02:43 +00:00
impl<E: Extension> QWrite for CalendarSelector<E> {
async fn qwrite(&self, xml: &mut Writer<impl IWrite>) -> Result<(), QError> {
2024-03-03 09:50:32 +00:00
match self {
2024-03-05 17:02:43 +00:00
Self::AllProp => {
let empty_tag = xml.create_dav_element("allprop");
xml.q.write_event_async(Event::Empty(empty_tag)).await
2024-05-16 15:38:34 +00:00
}
2024-03-05 17:02:43 +00:00
Self::PropName => {
let empty_tag = xml.create_dav_element("propname");
xml.q.write_event_async(Event::Empty(empty_tag)).await
2024-05-16 15:38:34 +00:00
}
2024-03-05 17:02:43 +00:00
Self::Prop(prop) => prop.qwrite(xml).await,
2024-03-03 09:50:32 +00:00
}
2024-03-02 15:52:52 +00:00
}
}
2024-03-05 17:02:43 +00:00
impl QWrite for CompFilter {
async fn qwrite(&self, xml: &mut Writer<impl IWrite>) -> Result<(), QError> {
let mut start = xml.create_cal_element("comp-filter");
2024-03-03 09:50:32 +00:00
start.push_attribute(("name", self.name.as_str()));
match &self.additional_rules {
2024-03-05 17:02:43 +00:00
None => xml.q.write_event_async(Event::Empty(start)).await,
2024-03-03 09:50:32 +00:00
Some(rules) => {
let end = start.to_end();
2024-03-05 17:02:43 +00:00
xml.q.write_event_async(Event::Start(start.clone())).await?;
rules.qwrite(xml).await?;
xml.q.write_event_async(Event::End(end)).await
2024-03-03 09:50:32 +00:00
}
}
2024-03-02 15:52:52 +00:00
}
}
2024-03-05 17:02:43 +00:00
impl QWrite for CompFilterRules {
async fn qwrite(&self, xml: &mut Writer<impl IWrite>) -> Result<(), QError> {
2024-03-03 09:50:32 +00:00
match self {
2024-05-16 15:38:34 +00:00
Self::IsNotDefined => {
2024-03-05 17:02:43 +00:00
let empty_tag = xml.create_dav_element("is-not-defined");
xml.q.write_event_async(Event::Empty(empty_tag)).await
2024-05-16 15:38:34 +00:00
}
2024-03-05 17:02:43 +00:00
Self::Matches(cfm) => cfm.qwrite(xml).await,
2024-03-03 09:50:32 +00:00
}
2024-03-02 15:52:52 +00:00
}
}
2024-03-05 17:02:43 +00:00
impl QWrite for CompFilterMatch {
async fn qwrite(&self, xml: &mut Writer<impl IWrite>) -> Result<(), QError> {
2024-03-03 09:50:32 +00:00
if let Some(time_range) = &self.time_range {
2024-03-05 17:02:43 +00:00
time_range.qwrite(xml).await?;
2024-03-03 09:50:32 +00:00
}
for prop_item in self.prop_filter.iter() {
2024-03-05 17:02:43 +00:00
prop_item.qwrite(xml).await?;
2024-03-03 09:50:32 +00:00
}
for comp_item in self.comp_filter.iter() {
// Required: recursion in an async fn requires boxing
// rustc --explain E0733
2024-03-16 15:48:46 +00:00
// Cycle detected when computing type of ...
// For more information about this error, try `rustc --explain E0391`.
// https://github.com/rust-lang/rust/issues/78649
#[inline(always)]
2024-05-16 15:38:34 +00:00
fn recurse<'a>(
comp: &'a CompFilter,
xml: &'a mut Writer<impl IWrite>,
) -> futures::future::BoxFuture<'a, Result<(), QError>> {
2024-03-16 15:48:46 +00:00
Box::pin(comp.qwrite(xml))
}
recurse(comp_item, xml).await?;
2024-03-03 09:50:32 +00:00
}
Ok(())
2024-03-02 15:52:52 +00:00
}
}
2024-03-05 17:02:43 +00:00
impl QWrite for PropFilter {
async fn qwrite(&self, xml: &mut Writer<impl IWrite>) -> Result<(), QError> {
let mut start = xml.create_cal_element("prop-filter");
2024-03-08 20:39:12 +00:00
start.push_attribute(("name", self.name.0.as_str()));
2024-03-03 09:50:32 +00:00
match &self.additional_rules {
2024-03-05 17:02:43 +00:00
None => xml.q.write_event_async(Event::Empty(start.clone())).await,
2024-03-03 09:50:32 +00:00
Some(rules) => {
let end = start.to_end();
2024-03-05 17:02:43 +00:00
xml.q.write_event_async(Event::Start(start.clone())).await?;
rules.qwrite(xml).await?;
xml.q.write_event_async(Event::End(end)).await
2024-03-03 09:50:32 +00:00
}
}
2024-03-02 15:52:52 +00:00
}
}
2024-03-05 17:02:43 +00:00
impl QWrite for PropFilterRules {
async fn qwrite(&self, xml: &mut Writer<impl IWrite>) -> Result<(), QError> {
2024-03-03 09:50:32 +00:00
match self {
2024-03-05 17:02:43 +00:00
Self::IsNotDefined => {
let empty_tag = xml.create_dav_element("is-not-defined");
xml.q.write_event_async(Event::Empty(empty_tag)).await
2024-05-16 15:38:34 +00:00
}
2024-03-05 17:02:43 +00:00
Self::Match(prop_match) => prop_match.qwrite(xml).await,
2024-03-03 09:50:32 +00:00
}
2024-03-02 15:52:52 +00:00
}
}
2024-03-05 17:02:43 +00:00
impl QWrite for PropFilterMatch {
async fn qwrite(&self, xml: &mut Writer<impl IWrite>) -> Result<(), QError> {
2024-03-03 09:50:32 +00:00
if let Some(time_or_text) = &self.time_or_text {
2024-03-05 17:02:43 +00:00
time_or_text.qwrite(xml).await?;
2024-03-03 09:50:32 +00:00
}
for param_item in self.param_filter.iter() {
2024-03-05 17:02:43 +00:00
param_item.qwrite(xml).await?;
2024-03-03 09:50:32 +00:00
}
Ok(())
2024-03-01 09:29:16 +00:00
}
}
2024-02-29 19:40:40 +00:00
2024-03-05 17:02:43 +00:00
impl QWrite for TimeOrText {
async fn qwrite(&self, xml: &mut Writer<impl IWrite>) -> Result<(), QError> {
2024-03-03 09:50:32 +00:00
match self {
2024-03-05 17:02:43 +00:00
Self::Time(time) => time.qwrite(xml).await,
Self::Text(txt) => txt.qwrite(xml).await,
2024-03-03 09:50:32 +00:00
}
2024-03-02 15:52:52 +00:00
}
}
2024-03-05 17:02:43 +00:00
impl QWrite for TextMatch {
async fn qwrite(&self, xml: &mut Writer<impl IWrite>) -> Result<(), QError> {
let mut start = xml.create_cal_element("text-match");
2024-03-03 10:00:10 +00:00
if let Some(collation) = &self.collation {
start.push_attribute(("collation", collation.as_str()));
}
match self.negate_condition {
None => (),
Some(true) => start.push_attribute(("negate-condition", "yes")),
Some(false) => start.push_attribute(("negate-condition", "no")),
}
let end = start.to_end();
2024-03-05 17:02:43 +00:00
xml.q.write_event_async(Event::Start(start.clone())).await?;
2024-05-16 15:38:34 +00:00
xml.q
.write_event_async(Event::Text(BytesText::new(self.text.as_str())))
.await?;
2024-03-05 17:02:43 +00:00
xml.q.write_event_async(Event::End(end)).await
2024-03-02 15:52:52 +00:00
}
}
2024-03-05 17:02:43 +00:00
impl QWrite for ParamFilter {
async fn qwrite(&self, xml: &mut Writer<impl IWrite>) -> Result<(), QError> {
let mut start = xml.create_cal_element("param-filter");
2024-03-03 10:00:10 +00:00
start.push_attribute(("name", self.name.as_str()));
match &self.additional_rules {
2024-03-05 17:02:43 +00:00
None => xml.q.write_event_async(Event::Empty(start)).await,
2024-03-03 10:00:10 +00:00
Some(rules) => {
let end = start.to_end();
2024-03-05 17:02:43 +00:00
xml.q.write_event_async(Event::Start(start.clone())).await?;
rules.qwrite(xml).await?;
xml.q.write_event_async(Event::End(end)).await
2024-03-03 10:00:10 +00:00
}
}
2024-03-02 15:52:52 +00:00
}
}
2024-03-05 17:02:43 +00:00
impl QWrite for ParamFilterMatch {
async fn qwrite(&self, xml: &mut Writer<impl IWrite>) -> Result<(), QError> {
2024-03-03 10:00:10 +00:00
match self {
2024-03-05 17:02:43 +00:00
Self::IsNotDefined => {
let empty_tag = xml.create_dav_element("is-not-defined");
xml.q.write_event_async(Event::Empty(empty_tag)).await
2024-05-16 15:38:34 +00:00
}
2024-03-05 17:02:43 +00:00
Self::Match(tm) => tm.qwrite(xml).await,
2024-03-03 10:00:10 +00:00
}
2024-03-02 15:52:52 +00:00
}
}
2024-03-05 17:02:43 +00:00
impl QWrite for TimeZone {
async fn qwrite(&self, xml: &mut Writer<impl IWrite>) -> Result<(), QError> {
2024-03-08 08:55:33 +00:00
let start = xml.create_cal_element("timezone");
let end = start.to_end();
2024-03-02 15:52:52 +00:00
2024-03-05 17:02:43 +00:00
xml.q.write_event_async(Event::Start(start.clone())).await?;
2024-05-16 15:38:34 +00:00
xml.q
.write_event_async(Event::Text(BytesText::new(self.0.as_str())))
.await?;
2024-03-05 17:02:43 +00:00
xml.q.write_event_async(Event::End(end)).await
2024-03-02 15:52:52 +00:00
}
}
2024-03-05 17:02:43 +00:00
impl QWrite for Filter {
async fn qwrite(&self, xml: &mut Writer<impl IWrite>) -> Result<(), QError> {
2024-03-08 08:55:33 +00:00
let start = xml.create_cal_element("filter");
let end = start.to_end();
2024-03-02 15:52:52 +00:00
2024-03-05 17:02:43 +00:00
xml.q.write_event_async(Event::Start(start.clone())).await?;
self.0.qwrite(xml).await?;
xml.q.write_event_async(Event::End(end)).await
2024-03-02 15:52:52 +00:00
}
}
2024-03-05 17:02:43 +00:00
impl QWrite for TimeRange {
async fn qwrite(&self, xml: &mut Writer<impl IWrite>) -> Result<(), QError> {
let mut empty = xml.create_cal_element("time-range");
match self {
2024-05-16 15:38:34 +00:00
Self::OnlyStart(start) => empty.push_attribute((
"start",
format!("{}", start.format(ICAL_DATETIME_FMT)).as_str(),
)),
Self::OnlyEnd(end) => {
empty.push_attribute(("end", format!("{}", end.format(ICAL_DATETIME_FMT)).as_str()))
}
Self::FullRange(start, end) => {
2024-05-16 15:38:34 +00:00
empty.push_attribute((
"start",
format!("{}", start.format(ICAL_DATETIME_FMT)).as_str(),
));
empty
.push_attribute(("end", format!("{}", end.format(ICAL_DATETIME_FMT)).as_str()));
}
}
2024-03-05 17:02:43 +00:00
xml.q.write_event_async(Event::Empty(empty)).await
2024-03-02 15:52:52 +00:00
}
}
2024-02-29 19:40:40 +00:00
#[cfg(test)]
mod tests {
use super::*;
2024-03-08 07:17:03 +00:00
use crate::realization::Calendar;
2024-05-16 15:38:34 +00:00
use crate::types as dav;
use chrono::{TimeZone, Utc};
2024-02-29 19:40:40 +00:00
use tokio::io::AsyncWriteExt;
2024-03-05 17:15:03 +00:00
async fn serialize(elem: &impl QWrite) -> String {
2024-02-29 19:40:40 +00:00
let mut buffer = Vec::new();
let mut tokio_buffer = tokio::io::BufWriter::new(&mut buffer);
2024-03-05 17:15:03 +00:00
let q = quick_xml::writer::Writer::new_with_indent(&mut tokio_buffer, b' ', 4);
2024-05-16 15:38:34 +00:00
let ns_to_apply = vec![
2024-03-05 17:15:03 +00:00
("xmlns:D".into(), "DAV:".into()),
("xmlns:C".into(), "urn:ietf:params:xml:ns:caldav".into()),
];
let mut writer = Writer { q, ns_to_apply };
elem.qwrite(&mut writer).await.expect("xml serialization");
2024-03-03 10:26:32 +00:00
tokio_buffer.flush().await.expect("tokio buffer flush");
let got = std::str::from_utf8(buffer.as_slice()).unwrap();
2024-02-29 19:40:40 +00:00
2024-05-16 15:38:34 +00:00
return got.into();
2024-03-03 10:26:32 +00:00
}
2024-02-29 19:40:40 +00:00
2024-03-03 10:26:32 +00:00
#[tokio::test]
async fn basic_violation() {
2024-05-16 15:38:34 +00:00
let got = serialize(&dav::Error::<Calendar>(vec![dav::Violation::Extension(
Violation::ResourceMustBeNull,
)]))
.await;
2024-02-29 19:40:40 +00:00
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>"#;
2024-05-16 15:38:34 +00:00
assert_eq!(
&got, expected,
"\n---GOT---\n{got}\n---EXP---\n{expected}\n"
);
2024-03-03 10:26:32 +00:00
}
#[tokio::test]
2024-03-04 08:29:03 +00:00
async fn rfc_calendar_query1_req() {
2024-05-16 15:38:34 +00:00
let got = serialize(&CalendarQuery::<Calendar> {
selector: Some(CalendarSelector::Prop(dav::PropName(vec![
dav::PropertyRequest::GetEtag,
dav::PropertyRequest::Extension(PropertyRequest::CalendarData(
CalendarDataRequest {
2024-03-03 12:07:22 +00:00
mime: None,
comp: Some(Comp {
name: Component::VCalendar,
2024-05-16 15:38:34 +00:00
prop_kind: Some(PropKind::Prop(vec![CalProp {
name: ComponentProperty("VERSION".into()),
novalue: None,
}])),
2024-03-12 09:18:13 +00:00
comp_kind: Some(CompKind::Comp(vec![
2024-05-16 15:38:34 +00:00
Comp {
name: Component::VEvent,
prop_kind: Some(PropKind::Prop(vec![
CalProp {
name: ComponentProperty("SUMMARY".into()),
novalue: None,
},
CalProp {
name: ComponentProperty("UID".into()),
novalue: None,
},
CalProp {
name: ComponentProperty("DTSTART".into()),
novalue: None,
},
CalProp {
name: ComponentProperty("DTEND".into()),
novalue: None,
},
CalProp {
name: ComponentProperty("DURATION".into()),
novalue: None,
},
CalProp {
name: ComponentProperty("RRULE".into()),
novalue: None,
},
CalProp {
name: ComponentProperty("RDATE".into()),
novalue: None,
},
CalProp {
name: ComponentProperty("EXRULE".into()),
novalue: None,
},
CalProp {
name: ComponentProperty("EXDATE".into()),
novalue: None,
},
CalProp {
name: ComponentProperty("RECURRENCE-ID".into()),
novalue: None,
},
])),
comp_kind: None,
},
Comp {
name: Component::VTimeZone,
prop_kind: None,
comp_kind: None,
},
])),
}),
2024-03-03 12:07:22 +00:00
recurrence: None,
limit_freebusy_set: None,
2024-05-16 15:38:34 +00:00
},
)),
]))),
filter: Filter(CompFilter {
name: Component::VCalendar,
additional_rules: Some(CompFilterRules::Matches(CompFilterMatch {
time_range: None,
prop_filter: vec![],
comp_filter: vec![CompFilter {
name: Component::VEvent,
additional_rules: Some(CompFilterRules::Matches(CompFilterMatch {
time_range: Some(TimeRange::FullRange(
Utc.with_ymd_and_hms(2006, 1, 4, 0, 0, 0).unwrap(),
Utc.with_ymd_and_hms(2006, 1, 5, 0, 0, 0).unwrap(),
)),
prop_filter: vec![],
comp_filter: vec![],
})),
}],
})),
}),
timezone: None,
})
.await;
2024-03-03 10:26:32 +00:00
let expected = r#"<C:calendar-query xmlns:D="DAV:" xmlns:C="urn:ietf:params:xml:ns:caldav">
<D:prop>
<D:getetag/>
<C:calendar-data>
<C:comp name="VCALENDAR">
<C:prop name="VERSION"/>
<C:comp name="VEVENT">
<C:prop name="SUMMARY"/>
<C:prop name="UID"/>
<C:prop name="DTSTART"/>
<C:prop name="DTEND"/>
<C:prop name="DURATION"/>
<C:prop name="RRULE"/>
<C:prop name="RDATE"/>
<C:prop name="EXRULE"/>
<C:prop name="EXDATE"/>
<C:prop name="RECURRENCE-ID"/>
</C:comp>
<C:comp name="VTIMEZONE"/>
</C:comp>
</C:calendar-data>
</D:prop>
<C:filter>
<C:comp-filter name="VCALENDAR">
<C:comp-filter name="VEVENT">
<C:time-range start="20060104T000000Z" end="20060105T000000Z"/>
</C:comp-filter>
</C:comp-filter>
</C:filter>
</C:calendar-query>"#;
2024-05-16 15:38:34 +00:00
assert_eq!(
&got, expected,
"\n---GOT---\n{got}\n---EXP---\n{expected}\n"
);
2024-03-04 08:29:03 +00:00
}
#[tokio::test]
async fn rfc_calendar_query1_res() {
2024-05-16 15:38:34 +00:00
let got = serialize(&dav::Multistatus::<Calendar> {
responses: vec![
dav::Response {
status_or_propstat: dav::StatusOrPropstat::PropStat(
dav::Href("http://cal.example.com/bernard/work/abcd2.ics".into()),
vec![dav::PropStat {
2024-03-18 19:45:30 +00:00
prop: dav::AnyProp(vec![
2024-05-16 15:38:34 +00:00
dav::AnyProperty::Value(dav::Property::GetEtag(
"\"fffff-abcd2\"".into(),
)),
dav::AnyProperty::Value(dav::Property::Extension(
Property::CalendarData(CalendarDataPayload {
mime: None,
payload: "PLACEHOLDER".into(),
}),
)),
2024-03-06 19:58:41 +00:00
]),
2024-03-04 08:29:03 +00:00
status: dav::Status(http::status::StatusCode::OK),
error: None,
responsedescription: None,
2024-05-16 15:38:34 +00:00
}],
),
location: None,
error: None,
responsedescription: None,
},
dav::Response {
status_or_propstat: dav::StatusOrPropstat::PropStat(
dav::Href("http://cal.example.com/bernard/work/abcd3.ics".into()),
vec![dav::PropStat {
2024-03-18 19:45:30 +00:00
prop: dav::AnyProp(vec![
2024-05-16 15:38:34 +00:00
dav::AnyProperty::Value(dav::Property::GetEtag(
"\"fffff-abcd3\"".into(),
)),
dav::AnyProperty::Value(dav::Property::Extension(
Property::CalendarData(CalendarDataPayload {
mime: None,
payload: "PLACEHOLDER".into(),
}),
)),
2024-03-06 19:58:41 +00:00
]),
2024-03-04 08:29:03 +00:00
status: dav::Status(http::status::StatusCode::OK),
error: None,
responsedescription: None,
2024-05-16 15:38:34 +00:00
}],
),
location: None,
error: None,
responsedescription: None,
},
],
responsedescription: None,
})
.await;
2024-03-04 08:29:03 +00:00
let expected = r#"<D:multistatus xmlns:D="DAV:" xmlns:C="urn:ietf:params:xml:ns:caldav">
<D:response>
<D:href>http://cal.example.com/bernard/work/abcd2.ics</D:href>
<D:propstat>
<D:prop>
<D:getetag>&quot;fffff-abcd2&quot;</D:getetag>
<C:calendar-data>PLACEHOLDER</C:calendar-data>
</D:prop>
<D:status>HTTP/1.1 200 OK</D:status>
</D:propstat>
</D:response>
<D:response>
<D:href>http://cal.example.com/bernard/work/abcd3.ics</D:href>
<D:propstat>
<D:prop>
<D:getetag>&quot;fffff-abcd3&quot;</D:getetag>
<C:calendar-data>PLACEHOLDER</C:calendar-data>
</D:prop>
<D:status>HTTP/1.1 200 OK</D:status>
</D:propstat>
</D:response>
</D:multistatus>"#;
2024-05-16 15:38:34 +00:00
assert_eq!(
&got, expected,
"\n---GOT---\n{got}\n---EXP---\n{expected}\n"
);
2024-02-29 19:40:40 +00:00
}
}