Migrate all deserialization business to rustical_xml

crates/caldav/src/calendar/prop.rs

@@ -1,20 +1,20 @@
-use serde::{Deserialize, Serialize};
+use serde::Serialize;
 
-#[derive(Debug, Clone, Deserialize, Serialize, PartialEq)]
+#[derive(Debug, Clone, Serialize, PartialEq)]
 #[serde(rename_all = "kebab-case")]
 pub struct SupportedCalendarComponent {
     #[serde(rename = "@name")]
     pub name: String,
 }
 
-#[derive(Debug, Clone, Deserialize, Serialize, PartialEq)]
+#[derive(Debug, Clone, Serialize, PartialEq)]
 #[serde(rename_all = "kebab-case")]
 pub struct SupportedCalendarComponentSet {
     #[serde(rename = "C:comp")]
     pub comp: Vec<SupportedCalendarComponent>,
 }
 
-#[derive(Debug, Clone, Deserialize, Serialize, PartialEq)]
+#[derive(Debug, Clone, Serialize, PartialEq)]
 #[serde(rename_all = "kebab-case")]
 pub struct CalendarData {
     #[serde(rename = "@content-type")]

crates/caldav/src/calendar/resource.rs

@@ -19,7 +19,8 @@ use rustical_dav::resource::{Resource, ResourceService};
 use rustical_dav::xml::HrefElement;
 use rustical_store::auth::User;
 use rustical_store::{Calendar, CalendarStore};
-use serde::{Deserialize, Serialize};
+use rustical_xml::XmlDeserialize;
+use serde::Serialize;
 use sha2::{Digest, Sha256};
 use std::str::FromStr;
 use std::sync::Arc;
@@ -31,7 +32,7 @@ pub struct CalendarResourceService<C: CalendarStore + ?Sized> {
     calendar_id: String,
 }
 
-#[derive(Default, Deserialize, Serialize, PartialEq, EnumDiscriminants)]
+#[derive(Default, XmlDeserialize, Serialize, PartialEq, EnumDiscriminants)]
 #[strum_discriminants(
     name(CalendarPropName),
     derive(EnumString, VariantNames),
@@ -48,6 +49,7 @@ pub enum CalendarProp {
     // in DAVx5 yet
     // https://github.com/bitfireAT/webdav-push/commit/461259a2f2174454b2b00033419b11fac52b79e3
     #[serde(skip_deserializing)]
+    #[xml(skip_deserializing)]
     #[serde(rename = "P:push-transports", alias = "push-transports")]
     Transports(Transports),
     Topic(String),
@@ -65,15 +67,19 @@ pub enum CalendarProp {
         rename = "C:supported-calendar-component-set",
         alias = "supported-calendar-component-set"
     )]
+    // TODO: Re-add
+    #[xml(skip_deserializing)]
     SupportedCalendarComponentSet(SupportedCalendarComponentSet),
     #[serde(
         rename = "C:supported-calendar-data",
         alias = "supported-calendar-data"
     )]
     #[serde(skip_deserializing)]
+    #[xml(skip_deserializing)]
     SupportedCalendarData(SupportedCalendarData),
     MaxResourceSize(i64),
     #[serde(skip_deserializing)]
+    #[xml(skip_deserializing)]
     SupportedReportSet(SupportedReportSet),
 
     // Collection Synchronization (RFC 6578)

crates/caldav/src/calendar_object/resource.rs

@@ -8,6 +8,7 @@ use rustical_dav::{
     resource::{Resource, ResourceService},
 };
 use rustical_store::{auth::User, CalendarObject, CalendarStore};
+use rustical_xml::XmlDeserialize;
 use serde::{Deserialize, Serialize};
 use std::sync::Arc;
 use strum::{EnumDiscriminants, EnumString, VariantNames};
@@ -19,7 +20,7 @@ pub struct CalendarObjectResourceService<C: CalendarStore + ?Sized> {
     object_id: String,
 }
 
-#[derive(Default, Deserialize, Serialize, PartialEq, EnumDiscriminants)]
+#[derive(Default, XmlDeserialize, Serialize, PartialEq, EnumDiscriminants)]
 #[strum_discriminants(
     name(CalendarObjectPropName),
     derive(EnumString, VariantNames),
@@ -36,6 +37,7 @@ pub enum CalendarObjectProp {
     CalendarData(String),
 
     #[serde(other)]
+    #[xml(other)]
     #[strum_discriminants(strum(disabled))]
     #[default]
     Invalid,

crates/caldav/src/principal/mod.rs

@@ -9,7 +9,8 @@ use rustical_dav::resource::{Resource, ResourceService};
 use rustical_dav::xml::HrefElement;
 use rustical_store::auth::User;
 use rustical_store::CalendarStore;
-use serde::{Deserialize, Serialize};
+use rustical_xml::XmlDeserialize;
+use serde::Serialize;
 use std::sync::Arc;
 use strum::{EnumDiscriminants, EnumString, VariantNames};
 
@@ -23,7 +24,7 @@ pub struct PrincipalResource {
     principal: String,
 }
 
-#[derive(Default, Deserialize, Serialize, PartialEq, EnumDiscriminants)]
+#[derive(Default, XmlDeserialize, Serialize, PartialEq, EnumDiscriminants)]
 #[strum_discriminants(
     name(PrincipalPropName),
     derive(EnumString, VariantNames),
@@ -43,6 +44,7 @@ pub enum PrincipalProp {
     CalendarUserAddressSet(HrefElement),
 
     #[serde(other)]
+    #[xml(other)]
     #[strum_discriminants(strum(disabled))]
     #[default]
     Invalid,

crates/carddav/src/address_object/resource.rs

@@ -7,6 +7,7 @@ use rustical_dav::{
     resource::{Resource, ResourceService},
 };
 use rustical_store::{auth::User, AddressObject, AddressbookStore};
+use rustical_xml::XmlDeserialize;
 use serde::{Deserialize, Serialize};
 use std::sync::Arc;
 use strum::{EnumDiscriminants, EnumString, VariantNames};
@@ -20,7 +21,7 @@ pub struct AddressObjectResourceService<AS: AddressbookStore + ?Sized> {
     object_id: String,
 }
 
-#[derive(Default, Deserialize, Serialize, PartialEq, EnumDiscriminants)]
+#[derive(Default, XmlDeserialize, Serialize, PartialEq, EnumDiscriminants)]
 #[strum_discriminants(
     name(AddressObjectPropName),
     derive(EnumString, VariantNames),
@@ -37,6 +38,7 @@ pub enum AddressObjectProp {
     AddressData(String),
 
     #[serde(other)]
+    #[xml(other)]
     #[strum_discriminants(strum(disabled))]
     #[default]
     Invalid,

crates/carddav/src/addressbook/resource.rs

@@ -14,7 +14,8 @@ use rustical_dav::privileges::UserPrivilegeSet;
 use rustical_dav::resource::{Resource, ResourceService};
 use rustical_store::auth::User;
 use rustical_store::{Addressbook, AddressbookStore};
-use serde::{Deserialize, Serialize};
+use rustical_xml::XmlDeserialize;
+use serde::Serialize;
 use std::str::FromStr;
 use std::sync::Arc;
 use strum::{EnumDiscriminants, EnumString, VariantNames};
@@ -25,7 +26,7 @@ pub struct AddressbookResourceService<AS: AddressbookStore + ?Sized> {
     addressbook_id: String,
 }
 
-#[derive(Default, Deserialize, Serialize, PartialEq, EnumDiscriminants)]
+#[derive(Default, XmlDeserialize, Serialize, PartialEq, EnumDiscriminants)]
 #[serde(rename_all = "kebab-case")]
 #[strum_discriminants(
     name(AddressbookPropName),
@@ -48,8 +49,10 @@ pub enum AddressbookProp {
         alias = "supported-address-data"
     )]
     #[serde(skip_deserializing)]
+    #[xml(skip_deserializing)]
     SupportedAddressData(SupportedAddressData),
     #[serde(skip_deserializing)]
+    #[xml(skip_deserializing)]
     SupportedReportSet(SupportedReportSet),
     MaxResourceSize(i64),
 
@@ -60,6 +63,7 @@ pub enum AddressbookProp {
     Getctag(String),
 
     #[serde(other)]
+    #[xml(other)]
     #[strum_discriminants(strum(disabled))]
     #[default]
     Invalid,

crates/carddav/src/principal/mod.rs

@@ -9,7 +9,8 @@ use rustical_dav::resource::{Resource, ResourceService};
 use rustical_dav::xml::HrefElement;
 use rustical_store::auth::User;
 use rustical_store::AddressbookStore;
-use serde::{Deserialize, Serialize};
+use rustical_xml::XmlDeserialize;
+use serde::Serialize;
 use std::sync::Arc;
 use strum::{EnumDiscriminants, EnumString, VariantNames};
 
@@ -23,7 +24,7 @@ pub struct PrincipalResource {
     principal: String,
 }
 
-#[derive(Default, Deserialize, Serialize, PartialEq, EnumDiscriminants)]
+#[derive(Default, XmlDeserialize, Serialize, PartialEq, EnumDiscriminants)]
 #[strum_discriminants(
     name(PrincipalPropName),
     derive(EnumString, VariantNames),
@@ -43,6 +44,7 @@ pub enum PrincipalProp {
     PrincipalAddress(Option<HrefElement>),
 
     #[serde(other)]
+    #[xml(other)]
     #[strum_discriminants(strum(disabled))]
     #[default]
     Invalid,

crates/dav/src/error.rs

@@ -20,10 +20,7 @@ pub enum Error {
     PropReadOnly,
 
     #[error(transparent)]
-    NewXmlDeserializationError(#[from] rustical_xml::XmlDeError),
+    XmlDeserializationError(#[from] rustical_xml::XmlDeError),
-
-    #[error(transparent)]
-    XmlDeserializationError(#[from] quick_xml::DeError),
 
     #[error(transparent)]
     XmlSerializationError(#[from] quick_xml::SeError),
@@ -36,7 +33,6 @@ impl actix_web::error::ResponseError for Error {
             Self::NotFound => StatusCode::NOT_FOUND,
             Self::BadRequest(_) => StatusCode::BAD_REQUEST,
             Self::Unauthorized => StatusCode::UNAUTHORIZED,
-            Self::NewXmlDeserializationError(_) => StatusCode::BAD_REQUEST,
             Self::XmlDeserializationError(_) => StatusCode::BAD_REQUEST,
             Self::XmlSerializationError(_) => StatusCode::BAD_REQUEST,
             Error::PropReadOnly => StatusCode::CONFLICT,

crates/dav/src/privileges.rs

@@ -1,8 +1,8 @@
-use serde::{Deserialize, Serialize};
+use rustical_xml::XmlDeserialize;
+use serde::Serialize;
 use std::collections::HashSet;
 
-#[derive(Debug, Clone, Serialize, Deserialize, Eq, Hash, PartialEq)]
+#[derive(Debug, Clone, Serialize, XmlDeserialize, Eq, Hash, PartialEq)]
-#[serde(rename_all = "kebab-case")]
 pub enum UserPrivilege {
     Read,
     Write,
@@ -42,10 +42,9 @@ impl Serialize for UserPrivilegeSet {
     }
 }
 
-// TODO: implement Deserialize once we need it
+#[derive(Debug, Clone, XmlDeserialize, Default, PartialEq)]
-#[derive(Debug, Clone, Deserialize, Default, PartialEq)]
-#[serde(rename_all = "kebab-case")]
 pub struct UserPrivilegeSet {
+    #[xml(flatten)]
     privileges: HashSet<UserPrivilege>,
 }
 

crates/dav/src/resource/methods/propfind.rs

@@ -42,7 +42,7 @@ pub(crate) async fn route_propfind<R: ResourceService>(
 
     // A request body is optional. If empty we MUST return all props
     let propfind: PropfindElement = if !body.is_empty() {
-        PropfindElement::parse_str(&body).map_err(Error::NewXmlDeserializationError)?
+        PropfindElement::parse_str(&body).map_err(Error::XmlDeserializationError)?
     } else {
         PropfindElement {
             prop: PropfindType::Allprop,

crates/dav/src/resource/methods/proppatch.rs

@@ -5,47 +5,53 @@ use crate::resource::ResourceService;
 use crate::xml::multistatus::{PropstatElement, PropstatWrapper, ResponseElement};
 use crate::xml::MultistatusElement;
 use crate::xml::TagList;
-use crate::xml::TagName;
 use crate::Error;
 use actix_web::http::StatusCode;
 use actix_web::{web::Path, HttpRequest};
 use rustical_store::auth::User;
-use serde::{Deserialize, Serialize};
+use rustical_xml::XmlDeserialize;
+use rustical_xml::XmlDocument;
+use rustical_xml::XmlRootTag;
 use std::str::FromStr;
 use tracing::instrument;
 use tracing_actix_web::RootSpan;
 
-// https://docs.rs/quick-xml/latest/quick_xml/de/index.html#normal-enum-variant
+#[derive(XmlDeserialize, Clone, Debug)]
-#[derive(Deserialize, Serialize, Clone, Debug)]
+struct SetPropertyElement<T: XmlDeserialize> {
-#[serde(rename_all = "kebab-case")]
-struct PropertyElement<T> {
-    #[serde(rename = "$value")]
     prop: T,
 }
 
-#[derive(Deserialize, Clone, Debug)]
+#[derive(XmlDeserialize, Clone, Debug)]
-#[serde(rename_all = "kebab-case")]
+struct TagName {
-struct SetPropertyElement<T> {
+    #[xml(ty = "tag_name")]
-    prop: PropertyElement<T>,
+    name: String,
 }
 
-#[derive(Deserialize, Clone, Debug)]
+#[derive(XmlDeserialize, Clone, Debug)]
-#[serde(rename_all = "kebab-case")]
+struct PropertyElement {
+    #[xml(ty = "untagged")]
+    property: TagName,
+}
+
+#[derive(XmlDeserialize, Clone, Debug)]
 struct RemovePropertyElement {
-    prop: PropertyElement<TagName>,
+    prop: PropertyElement,
 }
 
-#[derive(Deserialize, Clone, Debug)]
+#[derive(XmlDeserialize, Clone, Debug)]
-#[serde(rename_all = "kebab-case")]
+enum Operation<T: XmlDeserialize> {
-enum Operation<PropType> {
+    Set(SetPropertyElement<T>),
-    Set(SetPropertyElement<PropType>),
     Remove(RemovePropertyElement),
 }
 
-#[derive(Deserialize, Clone, Debug)]
+#[derive(XmlDeserialize, XmlRootTag, Clone, Debug)]
-#[serde(rename_all = "kebab-case")]
+#[xml(root = b"propertyupdate")]
-struct PropertyupdateElement<T> {
+struct PropertyupdateElement<T: XmlDeserialize> {
-    #[serde(rename = "$value", default = "Vec::new")]
+    // #[xml(flatten)]
+    // set: Vec<T>,
+    // #[xml(flatten)]
+    // remove: Vec<TagName>,
+    #[xml(ty = "untagged", flatten)]
     operations: Vec<Operation<T>>,
 }
 
@@ -63,18 +69,18 @@ pub(crate) async fn route_proppatch<R: ResourceService>(
 
     // Extract operations
     let PropertyupdateElement::<<R::Resource as Resource>::Prop> { operations } =
-        quick_xml::de::from_str(&body).map_err(Error::XmlDeserializationError)?;
+        XmlDocument::parse_str(&body).map_err(Error::XmlDeserializationError)?;
 
     // Extract all set property names without verification
     // Weird workaround because quick_xml doesn't allow untagged enums
-    let propnames: Vec<String> = quick_xml::de::from_str::<PropertyupdateElement<TagName>>(&body)
+    let propnames: Vec<String> = PropertyupdateElement::<TagName>::parse_str(&body)
         .map_err(Error::XmlDeserializationError)?
         .operations
         .into_iter()
         .map(|op_el| match op_el {
-            Operation::Set(set_el) => set_el.prop.prop.into(),
+            Operation::Set(set_el) => set_el.prop.name,
             // If we can't remove a nonexisting property then that's no big deal
-            Operation::Remove(remove_el) => remove_el.prop.prop.into(),
+            Operation::Remove(remove_el) => remove_el.prop.property.name,
         })
         .collect();
 
@@ -90,9 +96,7 @@ pub(crate) async fn route_proppatch<R: ResourceService>(
 
     for (operation, propname) in operations.into_iter().zip(propnames) {
         match operation {
-            Operation::Set(SetPropertyElement {
+            Operation::Set(SetPropertyElement { prop }) => {
-                prop: PropertyElement { prop },
-            }) => {
                 if prop.invalid_property() {
                     if <R::Resource as Resource>::list_props().contains(&propname.as_str()) {
                         // This happens in following cases:

crates/dav/src/resource/mod.rs

@@ -11,7 +11,8 @@ pub use invalid_property::InvalidProperty;
 use itertools::Itertools;
 pub use resource_service::ResourceService;
 use rustical_store::auth::User;
-use serde::{Deserialize, Serialize};
+use rustical_xml::XmlDeserialize;
+use serde::Serialize;
 use std::str::FromStr;
 use strum::{EnumString, VariantNames};
 
@@ -19,20 +20,21 @@ mod invalid_property;
 mod methods;
 mod resource_service;
 
-pub trait ResourceProp: InvalidProperty + Serialize + for<'de> Deserialize<'de> {}
+pub trait ResourceProp: InvalidProperty + Serialize + XmlDeserialize {}
-impl<T: InvalidProperty + Serialize + for<'de> Deserialize<'de>> ResourceProp for T {}
+impl<T: InvalidProperty + Serialize + XmlDeserialize> ResourceProp for T {}
 
 pub trait ResourcePropName: FromStr + VariantNames {}
 impl<T: FromStr + VariantNames> ResourcePropName for T {}
 
-pub trait ResourceType: Serialize + for<'de> Deserialize<'de> {}
+pub trait ResourceType: Serialize + XmlDeserialize {}
-impl<T: Serialize + for<'de> Deserialize<'de>> ResourceType for T {}
+impl<T: Serialize + XmlDeserialize> ResourceType for T {}
 
-#[derive(Deserialize, Serialize, PartialEq, Default)]
+#[derive(XmlDeserialize, Serialize, PartialEq, Default)]
 #[serde(rename_all = "kebab-case")]
 pub enum CommonPropertiesProp {
     // WebDAV (RFC 2518)
     #[serde(skip_deserializing)]
+    #[xml(skip_deserializing)]
     Resourcetype(Resourcetype),
 
     // WebDAV Current Principal Extension (RFC 5397)
@@ -40,7 +42,7 @@ pub enum CommonPropertiesProp {
 
     // WebDAV Access Control Protocol (RFC 3477)
     CurrentUserPrivilegeSet(UserPrivilegeSet),
-    Owner(Option<HrefElement>),
+    Owner(HrefElement),
 
     #[serde(other)]
     #[default]
@@ -97,11 +99,18 @@ pub trait Resource: Clone + 'static {
                 CommonPropertiesProp::CurrentUserPrivilegeSet(self.get_user_privileges(user)?)
             }
             CommonPropertiesPropName::Owner => {
-                CommonPropertiesProp::Owner(self.get_owner().map(|owner| {
+                // TODO: Reintroduce optional owner field
+                let owner = self.get_owner().unwrap_or(&user.id);
+                CommonPropertiesProp::Owner(
                     Self::PrincipalResource::get_url(rmap, [owner])
                         .unwrap()
-                        .into()
+                        .into(),
-                }))
+                )
+                // CommonPropertiesProp::Owner(self.get_owner().map(|owner| {
+                //     Self::PrincipalResource::get_url(rmap, [owner])
+                //         .unwrap()
+                //         .into()
+                // }))
             }
         })
     }

crates/dav/src/resources/root.rs

@@ -4,7 +4,8 @@ use actix_web::dev::ResourceMap;
 use actix_web::HttpRequest;
 use async_trait::async_trait;
 use rustical_store::auth::User;
-use serde::{Deserialize, Serialize};
+use rustical_xml::XmlDeserialize;
+use serde::Serialize;
 use std::any::type_name;
 use std::marker::PhantomData;
 use strum::{EnumString, VariantNames};
@@ -22,7 +23,7 @@ impl<PR: Resource> Default for RootResource<PR> {
 #[strum(serialize_all = "kebab-case")]
 pub enum RootResourcePropName {}
 
-#[derive(Deserialize, Serialize, Default, Clone, PartialEq)]
+#[derive(XmlDeserialize, Serialize, Default, Clone, PartialEq)]
 pub enum RootResourceProp {
     #[serde(other)]
     #[default]

crates/dav/src/xml/mod.rs

@@ -2,20 +2,15 @@ pub mod multistatus;
 mod propfind;
 mod resourcetype;
 pub mod tag_list;
-pub mod tag_name;
-
-pub use propfind::{PropElement, PropfindElement, PropfindType, Propname};
-
 use derive_more::derive::From;
 pub use multistatus::MultistatusElement;
-pub use tag_list::TagList;
+pub use propfind::{PropElement, PropfindElement, PropfindType, Propname};
-pub use tag_name::TagName;
-
 pub use resourcetype::Resourcetype;
+use rustical_xml::XmlDeserialize;
+use serde::Serialize;
+pub use tag_list::TagList;
 
-use serde::{Deserialize, Serialize};
+#[derive(XmlDeserialize, Debug, Clone, Serialize, From, PartialEq)]
-
-#[derive(Debug, Clone, Deserialize, Serialize, From, PartialEq)]
 pub struct HrefElement {
     pub href: String,
 }

crates/dav/src/xml/tag_name.rs

@@ -1,44 +0,0 @@
-use serde::{
-    de::{VariantAccess, Visitor},
-    Deserialize,
-};
-
-#[derive(Debug, Clone, PartialEq)]
-pub struct TagName(pub String);
-
-impl From<TagName> for String {
-    fn from(value: TagName) -> Self {
-        value.0
-    }
-}
-
-impl From<String> for TagName {
-    fn from(value: String) -> Self {
-        Self(value)
-    }
-}
-
-impl<'de> Deserialize<'de> for TagName {
-    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
-    where
-        D: serde::Deserializer<'de>,
-    {
-        struct __Visitor;
-
-        impl<'de> Visitor<'de> for __Visitor {
-            type Value = TagName;
-            fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
-                formatter.write_str("tagname")
-            }
-            fn visit_enum<A>(self, data: A) -> Result<Self::Value, A::Error>
-            where
-                A: serde::de::EnumAccess<'de>,
-            {
-                let (name, variant): (String, _) = data.variant()?;
-                VariantAccess::unit_variant(variant)?;
-                Ok(TagName(name))
-            }
-        }
-        deserializer.deserialize_enum("doesn't matter", &[], __Visitor)
-    }
-}