Refactoring that will hopefully make life easier

crates/caldav/src/calendar/methods/report/calendar_multiget.rs

@@ -0,0 +1,75 @@
+use crate::{
+    event::resource::{EventFile, EventProp},
+    Error,
+};
+use actix_web::HttpRequest;
+use rustical_dav::{
+    methods::propfind::{PropElement, PropfindType},
+    namespace::Namespace,
+    resource::HandlePropfind,
+    xml::{multistatus::PropstatWrapper, MultistatusElement},
+};
+use rustical_store::{event::Event, CalendarStore};
+use serde::Deserialize;
+use tokio::sync::RwLock;
+
+#[derive(Deserialize, Clone, Debug)]
+#[serde(rename_all = "kebab-case")]
+#[allow(dead_code)]
+// <!ELEMENT calendar-query ((DAV:allprop | DAV:propname | DAV:prop)?, href+)>
+pub struct CalendarMultigetRequest {
+    #[serde(flatten)]
+    prop: PropfindType,
+    href: Vec<String>,
+}
+
+pub async fn get_events_calendar_multiget<C: CalendarStore + ?Sized>(
+    _cal_query: &CalendarMultigetRequest,
+    principal: &str,
+    cid: &str,
+    store: &RwLock<C>,
+) -> Result<Vec<Event>, Error> {
+    // TODO: proper implementation
+    Ok(store.read().await.get_events(principal, cid).await?)
+}
+
+pub async fn handle_calendar_multiget<C: CalendarStore + ?Sized>(
+    cal_multiget: CalendarMultigetRequest,
+    req: HttpRequest,
+    prefix: &str,
+    principal: &str,
+    cid: &str,
+    cal_store: &RwLock<C>,
+) -> Result<MultistatusElement<PropstatWrapper<EventProp>, String>, Error> {
+    let events = get_events_calendar_multiget(&cal_multiget, principal, cid, cal_store).await?;
+
+    let props = match cal_multiget.prop {
+        PropfindType::Allprop => {
+            vec!["allprop".to_owned()]
+        }
+        PropfindType::Propname => {
+            // TODO: Implement
+            return Err(Error::NotImplemented);
+        }
+        PropfindType::Prop(PropElement { prop: prop_tags }) => prop_tags.into(),
+    };
+    let props: Vec<&str> = props.iter().map(String::as_str).collect();
+
+    let mut responses = Vec::new();
+    for event in events {
+        let path = format!("{}/{}", req.path(), event.get_uid());
+        responses.push(
+            EventFile { event }
+                .propfind(prefix, path, props.clone())
+                .await?,
+        );
+    }
+
+    Ok(MultistatusElement {
+        responses,
+        member_responses: vec![],
+        ns_dav: Namespace::Dav.as_str(),
+        ns_caldav: Namespace::CalDAV.as_str(),
+        ns_ical: Namespace::ICal.as_str(),
+    })
+}

crates/caldav/src/calendar/methods/report/calendar_query.rs

@@ -1,40 +1,21 @@
-use crate::{event::resource::EventFile, Error};
-use actix_web::{
-    web::{Data, Path},
-    HttpRequest, Responder,
-};
-use rustical_auth::{AuthInfoExtractor, CheckAuthentication};
+use actix_web::HttpRequest;
 use rustical_dav::{
-    methods::propfind::{PropElement, PropfindType, ServicePrefix},
+    methods::propfind::{PropElement, PropfindType},
     namespace::Namespace,
     resource::HandlePropfind,
-    xml::MultistatusElement,
+    xml::{multistatus::PropstatWrapper, MultistatusElement},
 };
-use rustical_store::event::Event;
-use rustical_store::CalendarStore;
-use serde::{Deserialize, Serialize};
+use rustical_store::{event::Event, CalendarStore};
+use serde::Deserialize;
 use tokio::sync::RwLock;
 
-#[derive(Deserialize, Serialize, Clone, Debug)]
-#[serde(rename_all = "kebab-case")]
-pub enum PropQuery {
-    Allprop,
-    Prop,
-    Propname,
-}
+use crate::{
+    event::resource::{EventFile, EventProp},
+    Error,
+};
 
 // TODO: Implement all the other filters
 
-#[derive(Deserialize, Clone, Debug)]
-#[serde(rename_all = "kebab-case")]
-#[allow(dead_code)]
-// <!ELEMENT calendar-query ((DAV:allprop | DAV:propname | DAV:prop)?, href+)>
-pub struct CalendarMultigetRequest {
-    #[serde(flatten)]
-    prop: PropfindType,
-    href: Vec<String>,
-}
-
 #[derive(Deserialize, Clone, Debug)]
 #[serde(rename_all = "kebab-case")]
 #[allow(dead_code)]
@@ -102,24 +83,16 @@ struct FilterElement {
 #[derive(Deserialize, Clone, Debug)]
 #[serde(rename_all = "kebab-case")]
 #[allow(dead_code)]
-// #[serde(rename = "calendar-query")]
 // <!ELEMENT calendar-query ((DAV:allprop | DAV:propname | DAV:prop)?, filter, timezone?)>
 pub struct CalendarQueryRequest {
     #[serde(flatten)]
-    prop: PropfindType,
+    pub prop: PropfindType,
     filter: Option<FilterElement>,
     timezone: Option<String>,
 }
 
-#[derive(Deserialize, Clone, Debug)]
-#[serde(rename_all = "kebab-case")]
-pub enum ReportRequest {
-    CalendarMultiget(CalendarMultigetRequest),
-    CalendarQuery(CalendarQueryRequest),
-}
-
-async fn get_events_calendar_query<C: CalendarStore + ?Sized>(
-    _cal_query: CalendarQueryRequest,
+pub async fn get_events_calendar_query<C: CalendarStore + ?Sized>(
+    _cal_query: &CalendarQueryRequest,
     principal: &str,
     cid: &str,
     store: &RwLock<C>,
@@ -128,45 +101,17 @@ async fn get_events_calendar_query<C: CalendarStore + ?Sized>(
     Ok(store.read().await.get_events(principal, cid).await?)
 }
 
-async fn get_events_calendar_multiget<C: CalendarStore + ?Sized>(
-    _cal_query: CalendarMultigetRequest,
+pub async fn handle_calendar_query<C: CalendarStore + ?Sized>(
+    cal_query: CalendarQueryRequest,
+    req: HttpRequest,
+    prefix: &str,
     principal: &str,
     cid: &str,
-    store: &RwLock<C>,
-) -> Result<Vec<Event>, Error> {
-    // TODO: proper implementation
-    Ok(store.read().await.get_events(principal, cid).await?)
-}
+    cal_store: &RwLock<C>,
+) -> Result<MultistatusElement<PropstatWrapper<EventProp>, String>, Error> {
+    let events = get_events_calendar_query(&cal_query, principal, cid, cal_store).await?;
 
-pub async fn route_report_calendar<A: CheckAuthentication, C: CalendarStore + ?Sized>(
-    path: Path<(String, String)>,
-    body: String,
-    auth: AuthInfoExtractor<A>,
-    req: HttpRequest,
-    cal_store: Data<RwLock<C>>,
-    prefix: Data<ServicePrefix>,
-) -> Result<impl Responder, Error> {
-    let (principal, cid) = path.into_inner();
-    if principal != auth.inner.user_id {
-        return Err(Error::Unauthorized);
-    }
-
-    let request: ReportRequest = quick_xml::de::from_str(&body)?;
-    let events = match request.clone() {
-        ReportRequest::CalendarQuery(cal_query) => {
-            get_events_calendar_query(cal_query, &principal, &cid, &cal_store).await?
-        }
-        ReportRequest::CalendarMultiget(cal_multiget) => {
-            get_events_calendar_multiget(cal_multiget, &principal, &cid, &cal_store).await?
-        }
-    };
-
-    // TODO: Change this
-    let proptag = match request {
-        ReportRequest::CalendarQuery(CalendarQueryRequest { prop, .. }) => prop.clone(),
-        ReportRequest::CalendarMultiget(CalendarMultigetRequest { prop, .. }) => prop.clone(),
-    };
-    let props = match proptag {
+    let props = match cal_query.prop {
         PropfindType::Allprop => {
             vec!["allprop".to_owned()]
         }
@@ -183,14 +128,14 @@ pub async fn route_report_calendar<A: CheckAuthentication, C: CalendarStore + ?S
         let path = format!("{}/{}", req.path(), event.get_uid());
         responses.push(
             EventFile { event }
-                .propfind(&prefix.0, path, props.clone())
+                .propfind(prefix, path, props.clone())
                 .await?,
         );
     }
 
     Ok(MultistatusElement {
         responses,
-        member_responses: Vec::<String>::new(),
+        member_responses: vec![],
         ns_dav: Namespace::Dav.as_str(),
         ns_caldav: Namespace::CalDAV.as_str(),
         ns_ical: Namespace::ICal.as_str(),

crates/caldav/src/calendar/methods/report/mod.rs

@@ -0,0 +1,72 @@
+use crate::Error;
+use actix_web::{
+    web::{Data, Path},
+    HttpRequest, Responder,
+};
+use calendar_multiget::{handle_calendar_multiget, CalendarMultigetRequest};
+use calendar_query::{handle_calendar_query, CalendarQueryRequest};
+use rustical_auth::{AuthInfoExtractor, CheckAuthentication};
+use rustical_dav::methods::propfind::ServicePrefix;
+use rustical_store::CalendarStore;
+use serde::{Deserialize, Serialize};
+use sync_collection::{handle_sync_collection, SyncCollectionRequest};
+use tokio::sync::RwLock;
+
+mod calendar_multiget;
+mod calendar_query;
+mod sync_collection;
+
+#[derive(Deserialize, Serialize, Clone, Debug)]
+#[serde(rename_all = "kebab-case")]
+pub enum PropQuery {
+    Allprop,
+    Prop,
+    Propname,
+}
+
+#[derive(Deserialize, Clone, Debug)]
+#[serde(rename_all = "kebab-case")]
+pub enum ReportRequest {
+    CalendarMultiget(CalendarMultigetRequest),
+    CalendarQuery(CalendarQueryRequest),
+    SyncCollection(SyncCollectionRequest),
+}
+
+pub async fn route_report_calendar<A: CheckAuthentication, C: CalendarStore + ?Sized>(
+    path: Path<(String, String)>,
+    body: String,
+    auth: AuthInfoExtractor<A>,
+    req: HttpRequest,
+    cal_store: Data<RwLock<C>>,
+    prefix: Data<ServicePrefix>,
+) -> Result<impl Responder, Error> {
+    let (principal, cid) = path.into_inner();
+    if principal != auth.inner.user_id {
+        return Err(Error::Unauthorized);
+    }
+
+    dbg!("REPORT request:", &body);
+    dbg!(req.headers().get("If"));
+    let request: ReportRequest = quick_xml::de::from_str(&body)?;
+
+    Ok(match request.clone() {
+        ReportRequest::CalendarQuery(cal_query) => {
+            handle_calendar_query(cal_query, req, &prefix.0, &principal, &cid, &cal_store).await?
+        }
+        ReportRequest::CalendarMultiget(cal_multiget) => {
+            handle_calendar_multiget(cal_multiget, req, &prefix.0, &principal, &cid, &cal_store)
+                .await?
+        }
+        ReportRequest::SyncCollection(sync_collection) => {
+            handle_sync_collection(
+                sync_collection,
+                req,
+                &prefix.0,
+                &principal,
+                &cid,
+                &cal_store,
+            )
+            .await?
+        }
+    })
+}

crates/caldav/src/calendar/methods/report/sync_collection.rs

@@ -0,0 +1,89 @@
+use actix_web::HttpRequest;
+use rustical_dav::{
+    methods::propfind::{PropElement, PropfindType},
+    namespace::Namespace,
+    resource::HandlePropfind,
+    xml::{multistatus::PropstatWrapper, MultistatusElement},
+};
+use rustical_store::{event::Event, CalendarStore};
+use serde::Deserialize;
+use tokio::sync::RwLock;
+
+use crate::{
+    event::resource::{EventFile, EventProp},
+    Error,
+};
+
+#[derive(Deserialize, Clone, Debug)]
+#[serde(rename_all = "kebab-case")]
+enum SyncLevel {
+    #[serde(rename = "1")]
+    One,
+    Infinity,
+}
+
+#[derive(Deserialize, Clone, Debug)]
+#[serde(rename_all = "kebab-case")]
+#[allow(dead_code)]
+// <!ELEMENT sync-collection (sync-token, sync-level, limit?, prop)>
+//    <!-- DAV:limit defined in RFC 5323, Section 5.17 -->
+//    <!-- DAV:prop defined in RFC 4918, Section 14.18 -->
+pub struct SyncCollectionRequest {
+    sync_token: String,
+    sync_level: SyncLevel,
+    timezone: Option<String>,
+    #[serde(flatten)]
+    pub prop: PropfindType,
+    limit: Option<u64>,
+}
+
+pub async fn get_events_sync_collection<C: CalendarStore + ?Sized>(
+    _sync_collection: &SyncCollectionRequest,
+    principal: &str,
+    cid: &str,
+    store: &RwLock<C>,
+) -> Result<Vec<Event>, Error> {
+    // TODO: proper implementation
+    Ok(store.read().await.get_events(principal, cid).await?)
+}
+
+pub async fn handle_sync_collection<C: CalendarStore + ?Sized>(
+    sync_collection: SyncCollectionRequest,
+    req: HttpRequest,
+    prefix: &str,
+    principal: &str,
+    cid: &str,
+    cal_store: &RwLock<C>,
+) -> Result<MultistatusElement<PropstatWrapper<EventProp>, String>, Error> {
+    let events = get_events_sync_collection(&sync_collection, principal, cid, cal_store).await?;
+
+    let props = match sync_collection.prop {
+        PropfindType::Allprop => {
+            vec!["allprop".to_owned()]
+        }
+        PropfindType::Propname => {
+            // TODO: Implement
+            return Err(Error::NotImplemented);
+        }
+        PropfindType::Prop(PropElement { prop: prop_tags }) => prop_tags.into(),
+    };
+    let props: Vec<&str> = props.iter().map(String::as_str).collect();
+
+    let mut responses = Vec::new();
+    for event in events {
+        let path = format!("{}/{}", req.path(), event.get_uid());
+        responses.push(
+            EventFile { event }
+                .propfind(prefix, path, props.clone())
+                .await?,
+        );
+    }
+
+    Ok(MultistatusElement {
+        responses,
+        member_responses: vec![],
+        ns_dav: Namespace::Dav.as_str(),
+        ns_caldav: Namespace::CalDAV.as_str(),
+        ns_ical: Namespace::ICal.as_str(),
+    })
+}

crates/caldav/src/calendar/prop.rs

@@ -101,25 +101,34 @@ impl Default for UserPrivilegeSet {
 pub enum ReportMethod {
     CalendarQuery,
     CalendarMultiget,
-    // SyncCollection,
+    SyncCollection,
 }
 
 #[derive(Debug, Clone, Deserialize, Serialize)]
 #[serde(rename_all = "kebab-case")]
-pub struct SupportedReport {
+pub struct ReportWrapper {
+    #[serde(rename = "$value")]
     report: ReportMethod,
 }
 
-impl From<ReportMethod> for SupportedReport {
+#[derive(Debug, Clone, Deserialize, Serialize)]
+#[serde(rename_all = "kebab-case")]
+pub struct SupportedReportWrapper {
+    report: ReportWrapper,
+}
+
+impl From<ReportMethod> for SupportedReportWrapper {
     fn from(value: ReportMethod) -> Self {
-        Self { report: value }
+        Self {
+            report: ReportWrapper { report: value },
+        }
     }
 }
 
 #[derive(Debug, Clone, Deserialize, Serialize)]
 #[serde(rename_all = "kebab-case")]
 pub struct SupportedReportSet {
-    supported_report: Vec<SupportedReport>,
+    supported_report: Vec<SupportedReportWrapper>,
 }
 
 impl Default for SupportedReportSet {
@@ -128,7 +137,7 @@ impl Default for SupportedReportSet {
             supported_report: vec![
                 ReportMethod::CalendarQuery.into(),
                 ReportMethod::CalendarMultiget.into(),
-                // ReportMethod::SyncCollection.into(),
+                ReportMethod::SyncCollection.into(),
             ],
         }
     }