caldav: Rewrite of MKCALENDAR method

crates/caldav/src/calendar/methods/mkcalendar.rs

@@ -0,0 +1,84 @@
+use crate::CalDavContext;
+use crate::Error;
+use actix_web::web::{Data, Path};
+use actix_web::HttpResponse;
+use anyhow::Result;
+use rustical_auth::{AuthInfoExtractor, CheckAuthentication};
+use rustical_store::calendar::{Calendar, CalendarStore};
+use serde::{Deserialize, Serialize};
+
+#[derive(Deserialize, Serialize, Clone, Debug)]
+#[serde(rename_all = "kebab-case")]
+pub struct Resourcetype {
+    #[serde(rename = "C:calendar", alias = "calendar")]
+    calendar: Option<()>,
+    collection: Option<()>,
+}
+
+#[derive(Serialize, Deserialize, Clone, Debug)]
+#[serde(rename_all = "kebab-case")]
+pub struct MkcolCalendarProp {
+    resourcetype: Resourcetype,
+    displayname: Option<String>,
+    calendar_description: Option<String>,
+    calendar_color: Option<String>,
+    calendar_timezone: Option<String>,
+}
+
+#[derive(Serialize, Deserialize, Clone, Debug)]
+pub struct PropElement<T: Serialize> {
+    prop: T,
+}
+
+#[derive(Serialize, Deserialize, Clone, Debug)]
+#[serde(rename_all = "kebab-case")]
+#[serde(rename = "mkcalendar")]
+struct MkcalendarRequest {
+    set: PropElement<MkcolCalendarProp>,
+}
+
+// TODO: Not sure yet what to send back :)
+#[derive(Serialize, Clone, Debug)]
+#[serde(rename = "mkcalendar-response")]
+struct MkcalendarResponse;
+
+pub async fn route_mkcol_calendar<A: CheckAuthentication, C: CalendarStore + ?Sized>(
+    path: Path<(String, String)>,
+    body: String,
+    auth: AuthInfoExtractor<A>,
+    context: Data<CalDavContext<C>>,
+) -> Result<HttpResponse, Error> {
+    let (principal, cid) = path.into_inner();
+    if principal != auth.inner.user_id {
+        return Err(Error::Unauthorized);
+    }
+
+    let request: MkcalendarRequest = quick_xml::de::from_str(&body).map_err(|e| {
+        dbg!(e.to_string());
+        Error::BadRequest
+    })?;
+    let request = request.set.prop;
+
+    let calendar = Calendar {
+        id: cid.to_owned(),
+        owner: principal,
+        name: request.displayname,
+        timezone: request.calendar_timezone,
+        color: request.calendar_color,
+        description: request.calendar_description,
+    };
+
+    match context
+        .store
+        .write()
+        .await
+        .insert_calendar(cid, calendar)
+        .await
+    {
+        Ok(()) => {
+            let response = quick_xml::se::to_string(&MkcalendarResponse).unwrap();
+            Ok(HttpResponse::Created().body(response))
+        }
+        Err(_err) => Ok(HttpResponse::InternalServerError().body("")),
+    }
+}

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

@@ -0,0 +1,103 @@
+use crate::event::resource::EventFile;
+use crate::CalDavContext;
+use crate::Error;
+use actix_web::http::header::ContentType;
+use actix_web::web::{Data, Path};
+use actix_web::HttpResponse;
+use anyhow::Result;
+use roxmltree::{Node, NodeType};
+use rustical_auth::{AuthInfoExtractor, CheckAuthentication};
+use rustical_dav::namespace::Namespace;
+use rustical_dav::propfind::ServicePrefix;
+use rustical_dav::resource::HandlePropfind;
+use rustical_dav::xml_snippets::generate_multistatus;
+use rustical_store::calendar::CalendarStore;
+use rustical_store::event::Event;
+
+pub mod mkcalendar;
+
+async fn handle_report_calendar_query(
+    query_node: Node<'_, '_>,
+    events: Vec<Event>,
+    prefix: &str,
+) -> Result<HttpResponse, Error> {
+    let prop_node = query_node
+        .children()
+        .find(|n| n.node_type() == NodeType::Element && n.tag_name().name() == "prop")
+        .ok_or(Error::BadRequest)?;
+
+    let props: Vec<&str> = prop_node
+        .children()
+        .map(|node| node.tag_name().name())
+        .collect();
+
+    let event_files: Vec<_> = events
+        .into_iter()
+        .map(|event| {
+            // TODO: fix
+            // let path = format!("{}/{}", request.path(), event.get_uid());
+            EventFile {
+                event, // cal_store: cal_store.clone(),
+            }
+        })
+        .collect();
+    let mut event_responses = Vec::new();
+    for event_file in event_files {
+        event_responses.push(event_file.propfind(prefix, props.clone()).await?);
+    }
+    // let event_results: Result<Vec<_>, _> = event_files
+    //     .iter()
+    //     .map(|ev| ev.propfind(props.clone()))
+    //     .collect();
+    // let event_responses = event_results?;
+
+    let output = generate_multistatus(vec![Namespace::Dav, Namespace::CalDAV], |writer| {
+        for result in event_responses {
+            writer
+                .write_serializable("response", &result)
+                .map_err(|_e| quick_xml::Error::TextNotFound)?;
+        }
+        Ok(())
+    })?;
+
+    Ok(HttpResponse::MultiStatus()
+        .content_type(ContentType::xml())
+        .body(output))
+}
+
+pub async fn route_report_calendar<A: CheckAuthentication, C: CalendarStore + ?Sized>(
+    context: Data<CalDavContext<C>>,
+    body: String,
+    path: Path<(String, String)>,
+    _auth: AuthInfoExtractor<A>,
+    prefix: Data<ServicePrefix>,
+) -> Result<HttpResponse, Error> {
+    // TODO: Check authorization
+    let (_principal, cid) = path.into_inner();
+    let prefix = &prefix.0;
+
+    let doc = roxmltree::Document::parse(&body).map_err(|_e| Error::BadRequest)?;
+    let query_node = doc.root_element();
+    let events = context.store.read().await.get_events(&cid).await.unwrap();
+
+    // TODO: implement filtering
+    match query_node.tag_name().name() {
+        "calendar-query" => {}
+        "calendar-multiget" => {}
+        _ => return Err(Error::BadRequest),
+    };
+    handle_report_calendar_query(query_node, events, prefix).await
+}
+
+pub async fn delete_calendar<A: CheckAuthentication, C: CalendarStore + ?Sized>(
+    context: Data<CalDavContext<C>>,
+    path: Path<(String, String)>,
+    auth: AuthInfoExtractor<A>,
+) -> Result<HttpResponse, Error> {
+    let _user = auth.inner.user_id;
+    // TODO: verify whether user is authorized
+    let (_principal, cid) = path.into_inner();
+    context.store.write().await.delete_calendar(&cid).await?;
+
+    Ok(HttpResponse::Ok().body(""))
+}