Move properties into separate files

crates/carddav/src/address_object/methods.rs

@@ -1,8 +1,6 @@
-use std::str::FromStr;
-
-use super::resource::AddressObjectPathComponents;
+use super::AddressObjectPathComponents;
+use super::AddressObjectResourceService;
 use crate::Error;
-use crate::address_object::resource::AddressObjectResourceService;
 use crate::addressbook::resource::AddressbookResource;
 use axum::body::Body;
 use axum::extract::{Path, State};
@@ -15,6 +13,7 @@ use rustical_dav::resource::Resource;
 use rustical_ical::AddressObject;
 use rustical_store::AddressbookStore;
 use rustical_store::auth::User;
+use std::str::FromStr;
 use tracing::instrument;
 
 #[instrument(skip(addr_store))]

crates/carddav/src/address_object/mod.rs

@@ -1,2 +1,6 @@
 pub mod methods;
 pub mod resource;
+mod service;
+pub use service::*;
+mod prop;
+pub use prop::*;

crates/carddav/src/address_object/prop.rs

@@ -0,0 +1,23 @@
+use rustical_dav::extensions::CommonPropertiesProp;
+use rustical_xml::{EnumVariants, PropName, XmlDeserialize, XmlSerialize};
+
+#[derive(XmlDeserialize, XmlSerialize, PartialEq, Clone, EnumVariants, PropName)]
+#[xml(unit_variants_ident = "AddressObjectPropName")]
+pub enum AddressObjectProp {
+    // WebDAV (RFC 2518)
+    #[xml(ns = "rustical_dav::namespace::NS_DAV")]
+    Getetag(String),
+    #[xml(ns = "rustical_dav::namespace::NS_DAV", skip_deserializing)]
+    Getcontenttype(&'static str),
+
+    // CalDAV (RFC 4791)
+    #[xml(ns = "rustical_dav::namespace::NS_CARDDAV")]
+    AddressData(String),
+}
+
+#[derive(XmlDeserialize, XmlSerialize, PartialEq, Clone, EnumVariants, PropName)]
+#[xml(unit_variants_ident = "AddressObjectPropWrapperName", untagged)]
+pub enum AddressObjectPropWrapper {
+    AddressObject(AddressObjectProp),
+    Common(CommonPropertiesProp),
+}

crates/carddav/src/address_object/resource.rs

@@ -1,56 +1,19 @@
-use crate::{CardDavPrincipalUri, Error};
-use async_trait::async_trait;
-use axum::{extract::Request, handler::Handler, response::Response};
-use derive_more::derive::{Constructor, From, Into};
-use futures_util::future::BoxFuture;
+use crate::{
+    Error,
+    address_object::{
+        AddressObjectProp, AddressObjectPropName, AddressObjectPropWrapper,
+        AddressObjectPropWrapperName,
+    },
+};
+use derive_more::derive::{From, Into};
 use rustical_dav::{
-    extensions::{CommonPropertiesExtension, CommonPropertiesProp},
+    extensions::CommonPropertiesExtension,
     privileges::UserPrivilegeSet,
-    resource::{AxumMethods, PrincipalUri, Resource, ResourceName, ResourceService},
+    resource::{PrincipalUri, Resource, ResourceName},
     xml::Resourcetype,
 };
 use rustical_ical::AddressObject;
-use rustical_store::{AddressbookStore, auth::User};
-use rustical_xml::{EnumVariants, PropName, XmlDeserialize, XmlSerialize};
-use serde::{Deserialize, Deserializer};
-use std::{convert::Infallible, sync::Arc};
-use tower::Service;
-
-use super::methods::{get_object, put_object};
-
-#[derive(Constructor)]
-pub struct AddressObjectResourceService<AS: AddressbookStore> {
-    pub(crate) addr_store: Arc<AS>,
-}
-
-impl<AS: AddressbookStore> Clone for AddressObjectResourceService<AS> {
-    fn clone(&self) -> Self {
-        Self {
-            addr_store: self.addr_store.clone(),
-        }
-    }
-}
-
-#[derive(XmlDeserialize, XmlSerialize, PartialEq, Clone, EnumVariants, PropName)]
-#[xml(unit_variants_ident = "AddressObjectPropName")]
-pub enum AddressObjectProp {
-    // WebDAV (RFC 2518)
-    #[xml(ns = "rustical_dav::namespace::NS_DAV")]
-    Getetag(String),
-    #[xml(ns = "rustical_dav::namespace::NS_DAV", skip_deserializing)]
-    Getcontenttype(&'static str),
-
-    // CalDAV (RFC 4791)
-    #[xml(ns = "rustical_dav::namespace::NS_CARDDAV")]
-    AddressData(String),
-}
-
-#[derive(XmlDeserialize, XmlSerialize, PartialEq, Clone, EnumVariants, PropName)]
-#[xml(unit_variants_ident = "AddressObjectPropWrapperName", untagged)]
-pub enum AddressObjectPropWrapper {
-    AddressObject(AddressObjectProp),
-    Common(CommonPropertiesProp),
-}
+use rustical_store::auth::User;
 
 #[derive(Clone, From, Into)]
 pub struct AddressObjectResource {
@@ -113,84 +76,3 @@ impl Resource for AddressObjectResource {
         ))
     }
 }
-
-fn deserialize_vcf_name<'de, D>(deserializer: D) -> Result<String, D::Error>
-where
-    D: Deserializer<'de>,
-{
-    let name: String = Deserialize::deserialize(deserializer)?;
-    if let Some(object_id) = name.strip_suffix(".vcf") {
-        Ok(object_id.to_owned())
-    } else {
-        Err(serde::de::Error::custom("Missing .vcf extension"))
-    }
-}
-
-#[derive(Debug, Clone, Deserialize)]
-pub struct AddressObjectPathComponents {
-    pub principal: String,
-    pub addressbook_id: String,
-    #[serde(deserialize_with = "deserialize_vcf_name")]
-    pub object_id: String,
-}
-
-#[async_trait]
-impl<AS: AddressbookStore> ResourceService for AddressObjectResourceService<AS> {
-    type PathComponents = AddressObjectPathComponents;
-    type Resource = AddressObjectResource;
-    type MemberType = AddressObjectResource;
-    type Error = Error;
-    type Principal = User;
-    type PrincipalUri = CardDavPrincipalUri;
-
-    const DAV_HEADER: &str = "1, 3, access-control, addressbook";
-
-    async fn get_resource(
-        &self,
-        AddressObjectPathComponents {
-            principal,
-            addressbook_id,
-            object_id,
-        }: &Self::PathComponents,
-    ) -> Result<Self::Resource, Self::Error> {
-        let object = self
-            .addr_store
-            .get_object(principal, addressbook_id, object_id, false)
-            .await?;
-        Ok(AddressObjectResource {
-            object,
-            principal: principal.to_owned(),
-        })
-    }
-
-    async fn delete_resource(
-        &self,
-        AddressObjectPathComponents {
-            principal,
-            addressbook_id,
-            object_id,
-        }: &Self::PathComponents,
-        use_trashbin: bool,
-    ) -> Result<(), Self::Error> {
-        self.addr_store
-            .delete_object(principal, addressbook_id, object_id, use_trashbin)
-            .await?;
-        Ok(())
-    }
-}
-
-impl<AS: AddressbookStore> AxumMethods for AddressObjectResourceService<AS> {
-    fn get() -> Option<fn(Self, Request) -> BoxFuture<'static, Result<Response, Infallible>>> {
-        Some(|state, req| {
-            let mut service = Handler::with_state(get_object::<AS>, state);
-            Box::pin(Service::call(&mut service, req))
-        })
-    }
-
-    fn put() -> Option<fn(Self, Request) -> BoxFuture<'static, Result<Response, Infallible>>> {
-        Some(|state, req| {
-            let mut service = Handler::with_state(put_object::<AS>, state);
-            Box::pin(Service::call(&mut service, req))
-        })
-    }
-}

crates/carddav/src/address_object/service.rs

@@ -0,0 +1,105 @@
+use super::methods::{get_object, put_object};
+use crate::{CardDavPrincipalUri, Error, address_object::resource::AddressObjectResource};
+use async_trait::async_trait;
+use axum::{extract::Request, handler::Handler, response::Response};
+use derive_more::derive::Constructor;
+use futures_util::future::BoxFuture;
+use rustical_dav::resource::{AxumMethods, ResourceService};
+use rustical_store::{AddressbookStore, auth::User};
+use serde::{Deserialize, Deserializer};
+use std::{convert::Infallible, sync::Arc};
+use tower::Service;
+
+#[derive(Constructor)]
+pub struct AddressObjectResourceService<AS: AddressbookStore> {
+    pub(crate) addr_store: Arc<AS>,
+}
+
+impl<AS: AddressbookStore> Clone for AddressObjectResourceService<AS> {
+    fn clone(&self) -> Self {
+        Self {
+            addr_store: self.addr_store.clone(),
+        }
+    }
+}
+
+#[derive(Debug, Clone, Deserialize)]
+pub struct AddressObjectPathComponents {
+    pub principal: String,
+    pub addressbook_id: String,
+    #[serde(deserialize_with = "deserialize_vcf_name")]
+    pub object_id: String,
+}
+
+#[async_trait]
+impl<AS: AddressbookStore> ResourceService for AddressObjectResourceService<AS> {
+    type PathComponents = AddressObjectPathComponents;
+    type Resource = AddressObjectResource;
+    type MemberType = AddressObjectResource;
+    type Error = Error;
+    type Principal = User;
+    type PrincipalUri = CardDavPrincipalUri;
+
+    const DAV_HEADER: &str = "1, 3, access-control, addressbook";
+
+    async fn get_resource(
+        &self,
+        AddressObjectPathComponents {
+            principal,
+            addressbook_id,
+            object_id,
+        }: &Self::PathComponents,
+    ) -> Result<Self::Resource, Self::Error> {
+        let object = self
+            .addr_store
+            .get_object(principal, addressbook_id, object_id, false)
+            .await?;
+        Ok(AddressObjectResource {
+            object,
+            principal: principal.to_owned(),
+        })
+    }
+
+    async fn delete_resource(
+        &self,
+        AddressObjectPathComponents {
+            principal,
+            addressbook_id,
+            object_id,
+        }: &Self::PathComponents,
+        use_trashbin: bool,
+    ) -> Result<(), Self::Error> {
+        self.addr_store
+            .delete_object(principal, addressbook_id, object_id, use_trashbin)
+            .await?;
+        Ok(())
+    }
+}
+
+impl<AS: AddressbookStore> AxumMethods for AddressObjectResourceService<AS> {
+    fn get() -> Option<fn(Self, Request) -> BoxFuture<'static, Result<Response, Infallible>>> {
+        Some(|state, req| {
+            let mut service = Handler::with_state(get_object::<AS>, state);
+            Box::pin(Service::call(&mut service, req))
+        })
+    }
+
+    fn put() -> Option<fn(Self, Request) -> BoxFuture<'static, Result<Response, Infallible>>> {
+        Some(|state, req| {
+            let mut service = Handler::with_state(put_object::<AS>, state);
+            Box::pin(Service::call(&mut service, req))
+        })
+    }
+}
+
+fn deserialize_vcf_name<'de, D>(deserializer: D) -> Result<String, D::Error>
+where
+    D: Deserializer<'de>,
+{
+    let name: String = Deserialize::deserialize(deserializer)?;
+    if let Some(object_id) = name.strip_suffix(".vcf") {
+        Ok(object_id.to_owned())
+    } else {
+        Err(serde::de::Error::custom("Missing .vcf extension"))
+    }
+}

crates/carddav/src/addressbook/methods/mkcol.rs

@@ -1,4 +1,4 @@
-use crate::{Error, addressbook::resource::AddressbookResourceService};
+use crate::{Error, addressbook::AddressbookResourceService};
 use axum::{
     extract::{Path, State},
     response::{IntoResponse, Response},

crates/carddav/src/addressbook/methods/report/addressbook_multiget.rs

@@ -1,7 +1,7 @@
 use crate::{
     Error,
-    address_object::resource::{
-        AddressObjectPropWrapper, AddressObjectPropWrapperName, AddressObjectResource,
+    address_object::{
+        AddressObjectPropWrapper, AddressObjectPropWrapperName, resource::AddressObjectResource,
     },
 };
 use http::StatusCode;

crates/carddav/src/addressbook/methods/report/mod.rs

@@ -1,6 +1,6 @@
 use crate::{
-    CardDavPrincipalUri, Error, address_object::resource::AddressObjectPropWrapperName,
-    addressbook::resource::AddressbookResourceService,
+    CardDavPrincipalUri, Error, address_object::AddressObjectPropWrapperName,
+    addressbook::AddressbookResourceService,
 };
 use addressbook_multiget::{AddressbookMultigetRequest, handle_addressbook_multiget};
 use axum::{
@@ -81,7 +81,7 @@ pub async fn route_report_addressbook<AS: AddressbookStore, S: SubscriptionStore
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::address_object::resource::AddressObjectPropName;
+    use crate::address_object::AddressObjectPropName;
     use rustical_dav::xml::{PropElement, sync_collection::SyncLevel};
 
     #[test]

crates/carddav/src/addressbook/methods/report/sync_collection.rs

@@ -1,7 +1,7 @@
 use crate::{
     Error,
-    address_object::resource::{
-        AddressObjectPropWrapper, AddressObjectPropWrapperName, AddressObjectResource,
+    address_object::{
+        AddressObjectPropWrapper, AddressObjectPropWrapperName, resource::AddressObjectResource,
     },
 };
 use http::StatusCode;

crates/carddav/src/addressbook/mod.rs

@@ -1,3 +1,5 @@
 pub mod methods;
 pub mod prop;
 pub mod resource;
+mod service;
+pub use service::*;

crates/carddav/src/addressbook/prop.rs

@@ -1,4 +1,33 @@
-use rustical_xml::XmlSerialize;
+use rustical_dav::extensions::{CommonPropertiesProp, SyncTokenExtensionProp};
+use rustical_dav_push::DavPushExtensionProp;
+use rustical_xml::{EnumVariants, PropName, XmlDeserialize, XmlSerialize};
+
+#[derive(XmlDeserialize, XmlSerialize, PartialEq, Clone, EnumVariants, PropName)]
+#[xml(unit_variants_ident = "AddressbookPropName")]
+pub enum AddressbookProp {
+    // WebDAV (RFC 2518)
+    #[xml(ns = "rustical_dav::namespace::NS_DAV")]
+    Displayname(Option<String>),
+
+    // CardDAV (RFC 6352)
+    #[xml(ns = "rustical_dav::namespace::NS_CARDDAV")]
+    AddressbookDescription(Option<String>),
+    #[xml(ns = "rustical_dav::namespace::NS_CARDDAV", skip_deserializing)]
+    SupportedAddressData(SupportedAddressData),
+    #[xml(ns = "rustical_dav::namespace::NS_CARDDAV", skip_deserializing)]
+    SupportedReportSet(SupportedReportSet),
+    #[xml(ns = "rustical_dav::namespace::NS_DAV")]
+    MaxResourceSize(i64),
+}
+
+#[derive(XmlDeserialize, XmlSerialize, PartialEq, Clone, EnumVariants, PropName)]
+#[xml(unit_variants_ident = "AddressbookPropWrapperName", untagged)]
+pub enum AddressbookPropWrapper {
+    Addressbook(AddressbookProp),
+    SyncToken(SyncTokenExtensionProp),
+    DavPush(DavPushExtensionProp),
+    Common(CommonPropertiesProp),
+}
 
 #[derive(Debug, Clone, XmlSerialize, PartialEq)]
 pub struct AddressDataType {

crates/carddav/src/addressbook/resource.rs

@@ -1,78 +1,16 @@
-use super::methods::mkcol::route_mkcol;
-use super::methods::report::route_report_addressbook;
 use super::prop::{SupportedAddressData, SupportedReportSet};
-use crate::address_object::resource::{AddressObjectResource, AddressObjectResourceService};
-use crate::{CardDavPrincipalUri, Error};
-use async_trait::async_trait;
-use axum::Router;
-use axum::extract::Request;
-use axum::handler::Handler;
-use axum::response::Response;
-use derive_more::derive::{From, Into};
-use futures_util::future::BoxFuture;
-use rustical_dav::extensions::{
-    CommonPropertiesExtension, CommonPropertiesProp, SyncTokenExtension, SyncTokenExtensionProp,
+use crate::Error;
+use crate::addressbook::prop::{
+    AddressbookProp, AddressbookPropName, AddressbookPropWrapper, AddressbookPropWrapperName,
 };
+use derive_more::derive::{From, Into};
+use rustical_dav::extensions::{CommonPropertiesExtension, SyncTokenExtension};
 use rustical_dav::privileges::UserPrivilegeSet;
-use rustical_dav::resource::{AxumMethods, PrincipalUri, Resource, ResourceName, ResourceService};
+use rustical_dav::resource::{PrincipalUri, Resource, ResourceName};
 use rustical_dav::xml::{Resourcetype, ResourcetypeInner};
-use rustical_dav_push::{DavPushExtension, DavPushExtensionProp};
+use rustical_dav_push::DavPushExtension;
+use rustical_store::Addressbook;
 use rustical_store::auth::User;
-use rustical_store::{Addressbook, AddressbookStore, SubscriptionStore};
-use rustical_xml::{EnumVariants, PropName, XmlDeserialize, XmlSerialize};
-use std::convert::Infallible;
-use std::sync::Arc;
-use tower::Service;
-
-pub struct AddressbookResourceService<AS: AddressbookStore, S: SubscriptionStore> {
-    pub(crate) addr_store: Arc<AS>,
-    pub(crate) sub_store: Arc<S>,
-}
-
-impl<A: AddressbookStore, S: SubscriptionStore> AddressbookResourceService<A, S> {
-    pub fn new(addr_store: Arc<A>, sub_store: Arc<S>) -> Self {
-        Self {
-            addr_store,
-            sub_store,
-        }
-    }
-}
-
-impl<A: AddressbookStore, S: SubscriptionStore> Clone for AddressbookResourceService<A, S> {
-    fn clone(&self) -> Self {
-        Self {
-            addr_store: self.addr_store.clone(),
-            sub_store: self.sub_store.clone(),
-        }
-    }
-}
-
-#[derive(XmlDeserialize, XmlSerialize, PartialEq, Clone, EnumVariants, PropName)]
-#[xml(unit_variants_ident = "AddressbookPropName")]
-pub enum AddressbookProp {
-    // WebDAV (RFC 2518)
-    #[xml(ns = "rustical_dav::namespace::NS_DAV")]
-    Displayname(Option<String>),
-
-    // CardDAV (RFC 6352)
-    #[xml(ns = "rustical_dav::namespace::NS_CARDDAV")]
-    AddressbookDescription(Option<String>),
-    #[xml(ns = "rustical_dav::namespace::NS_CARDDAV", skip_deserializing)]
-    SupportedAddressData(SupportedAddressData),
-    #[xml(ns = "rustical_dav::namespace::NS_CARDDAV", skip_deserializing)]
-    SupportedReportSet(SupportedReportSet),
-    #[xml(ns = "rustical_dav::namespace::NS_DAV")]
-    MaxResourceSize(i64),
-}
-
-#[derive(XmlDeserialize, XmlSerialize, PartialEq, Clone, EnumVariants, PropName)]
-#[xml(unit_variants_ident = "AddressbookPropWrapperName", untagged)]
-pub enum AddressbookPropWrapper {
-    Addressbook(AddressbookProp),
-    SyncToken(SyncTokenExtensionProp),
-    DavPush(DavPushExtensionProp),
-    Common(CommonPropertiesProp),
-}
 
 #[derive(Clone, Debug, From, Into)]
 pub struct AddressbookResource(pub(crate) Addressbook);
@@ -205,92 +143,3 @@ impl Resource for AddressbookResource {
         ))
     }
 }
-
-#[async_trait]
-impl<AS: AddressbookStore, S: SubscriptionStore> ResourceService
-    for AddressbookResourceService<AS, S>
-{
-    type MemberType = AddressObjectResource;
-    type PathComponents = (String, String); // principal, addressbook_id
-    type Resource = AddressbookResource;
-    type Error = Error;
-    type Principal = User;
-    type PrincipalUri = CardDavPrincipalUri;
-
-    const DAV_HEADER: &str = "1, 3, access-control, addressbook";
-
-    async fn get_resource(
-        &self,
-        (principal, addressbook_id): &Self::PathComponents,
-    ) -> Result<Self::Resource, Error> {
-        let addressbook = self
-            .addr_store
-            .get_addressbook(principal, addressbook_id, false)
-            .await
-            .map_err(|_e| Error::NotFound)?;
-        Ok(addressbook.into())
-    }
-
-    async fn get_members(
-        &self,
-        (principal, addressbook_id): &Self::PathComponents,
-    ) -> Result<Vec<Self::MemberType>, Self::Error> {
-        Ok(self
-            .addr_store
-            .get_objects(principal, addressbook_id)
-            .await?
-            .into_iter()
-            .map(|object| AddressObjectResource {
-                object,
-                principal: principal.to_owned(),
-            })
-            .collect())
-    }
-
-    async fn save_resource(
-        &self,
-        (principal, addressbook_id): &Self::PathComponents,
-        file: Self::Resource,
-    ) -> Result<(), Self::Error> {
-        self.addr_store
-            .update_addressbook(principal.to_owned(), addressbook_id.to_owned(), file.into())
-            .await?;
-        Ok(())
-    }
-
-    async fn delete_resource(
-        &self,
-        (principal, addressbook_id): &Self::PathComponents,
-        use_trashbin: bool,
-    ) -> Result<(), Self::Error> {
-        self.addr_store
-            .delete_addressbook(principal, addressbook_id, use_trashbin)
-            .await?;
-        Ok(())
-    }
-
-    fn axum_router<State: Send + Sync + Clone + 'static>(self) -> Router<State> {
-        Router::new()
-            .nest(
-                "/{object_id}",
-                AddressObjectResourceService::new(self.addr_store.clone()).axum_router(),
-            )
-            .route_service("/", self.axum_service())
-    }
-}
-
-impl<AS: AddressbookStore, S: SubscriptionStore> AxumMethods for AddressbookResourceService<AS, S> {
-    fn report() -> Option<fn(Self, Request) -> BoxFuture<'static, Result<Response, Infallible>>> {
-        Some(|state, req| {
-            let mut service = Handler::with_state(route_report_addressbook::<AS, S>, state);
-            Box::pin(Service::call(&mut service, req))
-        })
-    }
-
-    fn mkcol() -> Option<fn(Self, Request) -> BoxFuture<'static, Result<Response, Infallible>>> {
-        Some(|state, req| {
-            let mut service = Handler::with_state(route_mkcol::<AS, S>, state);
-            Box::pin(Service::call(&mut service, req))
-        })
-    }
-}

crates/carddav/src/addressbook/service.rs

@@ -0,0 +1,130 @@
+use super::methods::mkcol::route_mkcol;
+use super::methods::report::route_report_addressbook;
+use crate::address_object::AddressObjectResourceService;
+use crate::address_object::resource::AddressObjectResource;
+use crate::addressbook::resource::AddressbookResource;
+use crate::{CardDavPrincipalUri, Error};
+use async_trait::async_trait;
+use axum::Router;
+use axum::extract::Request;
+use axum::handler::Handler;
+use axum::response::Response;
+use futures_util::future::BoxFuture;
+use rustical_dav::resource::{AxumMethods, ResourceService};
+use rustical_store::auth::User;
+use rustical_store::{AddressbookStore, SubscriptionStore};
+use std::convert::Infallible;
+use std::sync::Arc;
+use tower::Service;
+
+pub struct AddressbookResourceService<AS: AddressbookStore, S: SubscriptionStore> {
+    pub(crate) addr_store: Arc<AS>,
+    pub(crate) sub_store: Arc<S>,
+}
+
+impl<A: AddressbookStore, S: SubscriptionStore> AddressbookResourceService<A, S> {
+    pub fn new(addr_store: Arc<A>, sub_store: Arc<S>) -> Self {
+        Self {
+            addr_store,
+            sub_store,
+        }
+    }
+}
+
+impl<A: AddressbookStore, S: SubscriptionStore> Clone for AddressbookResourceService<A, S> {
+    fn clone(&self) -> Self {
+        Self {
+            addr_store: self.addr_store.clone(),
+            sub_store: self.sub_store.clone(),
+        }
+    }
+}
+
+#[async_trait]
+impl<AS: AddressbookStore, S: SubscriptionStore> ResourceService
+    for AddressbookResourceService<AS, S>
+{
+    type MemberType = AddressObjectResource;
+    type PathComponents = (String, String); // principal, addressbook_id
+    type Resource = AddressbookResource;
+    type Error = Error;
+    type Principal = User;
+    type PrincipalUri = CardDavPrincipalUri;
+
+    const DAV_HEADER: &str = "1, 3, access-control, addressbook";
+
+    async fn get_resource(
+        &self,
+        (principal, addressbook_id): &Self::PathComponents,
+    ) -> Result<Self::Resource, Error> {
+        let addressbook = self
+            .addr_store
+            .get_addressbook(principal, addressbook_id, false)
+            .await
+            .map_err(|_e| Error::NotFound)?;
+        Ok(addressbook.into())
+    }
+
+    async fn get_members(
+        &self,
+        (principal, addressbook_id): &Self::PathComponents,
+    ) -> Result<Vec<Self::MemberType>, Self::Error> {
+        Ok(self
+            .addr_store
+            .get_objects(principal, addressbook_id)
+            .await?
+            .into_iter()
+            .map(|object| AddressObjectResource {
+                object,
+                principal: principal.to_owned(),
+            })
+            .collect())
+    }
+
+    async fn save_resource(
+        &self,
+        (principal, addressbook_id): &Self::PathComponents,
+        file: Self::Resource,
+    ) -> Result<(), Self::Error> {
+        self.addr_store
+            .update_addressbook(principal.to_owned(), addressbook_id.to_owned(), file.into())
+            .await?;
+        Ok(())
+    }
+
+    async fn delete_resource(
+        &self,
+        (principal, addressbook_id): &Self::PathComponents,
+        use_trashbin: bool,
+    ) -> Result<(), Self::Error> {
+        self.addr_store
+            .delete_addressbook(principal, addressbook_id, use_trashbin)
+            .await?;
+        Ok(())
+    }
+
+    fn axum_router<State: Send + Sync + Clone + 'static>(self) -> Router<State> {
+        Router::new()
+            .nest(
+                "/{object_id}",
+                AddressObjectResourceService::new(self.addr_store.clone()).axum_router(),
+            )
+            .route_service("/", self.axum_service())
+    }
+}
+
+impl<AS: AddressbookStore, S: SubscriptionStore> AxumMethods for AddressbookResourceService<AS, S> {
+    fn report() -> Option<fn(Self, Request) -> BoxFuture<'static, Result<Response, Infallible>>> {
+        Some(|state, req| {
+            let mut service = Handler::with_state(route_report_addressbook::<AS, S>, state);
+            Box::pin(Service::call(&mut service, req))
+        })
+    }
+
+    fn mkcol() -> Option<fn(Self, Request) -> BoxFuture<'static, Result<Response, Infallible>>> {
+        Some(|state, req| {
+            let mut service = Handler::with_state(route_mkcol::<AS, S>, state);
+            Box::pin(Service::call(&mut service, req))
+        })
+    }
+}

crates/carddav/src/principal/mod.rs

@@ -1,49 +1,14 @@
-use crate::addressbook::resource::{AddressbookResource, AddressbookResourceService};
-use crate::{CardDavPrincipalUri, Error};
-use async_trait::async_trait;
-use axum::Router;
-use rustical_dav::extensions::{CommonPropertiesExtension, CommonPropertiesProp};
+use crate::Error;
+use rustical_dav::extensions::CommonPropertiesExtension;
 use rustical_dav::privileges::UserPrivilegeSet;
-use rustical_dav::resource::{AxumMethods, PrincipalUri, Resource, ResourceName, ResourceService};
+use rustical_dav::resource::{PrincipalUri, Resource, ResourceName};
 use rustical_dav::xml::{HrefElement, Resourcetype, ResourcetypeInner};
-use rustical_store::auth::{AuthenticationProvider, User};
-use rustical_store::{AddressbookStore, SubscriptionStore};
-use rustical_xml::{EnumVariants, PropName, XmlDeserialize, XmlSerialize};
-use std::sync::Arc;
+use rustical_store::auth::User;
 
-pub struct PrincipalResourceService<
-    A: AddressbookStore,
-    AP: AuthenticationProvider,
-    S: SubscriptionStore,
-> {
-    addr_store: Arc<A>,
-    auth_provider: Arc<AP>,
-    sub_store: Arc<S>,
-}
-
-impl<A: AddressbookStore, AP: AuthenticationProvider, S: SubscriptionStore> Clone
-    for PrincipalResourceService<A, AP, S>
-{
-    fn clone(&self) -> Self {
-        Self {
-            addr_store: self.addr_store.clone(),
-            auth_provider: self.auth_provider.clone(),
-            sub_store: self.sub_store.clone(),
-        }
-    }
-}
-
-impl<A: AddressbookStore, AP: AuthenticationProvider, S: SubscriptionStore>
-    PrincipalResourceService<A, AP, S>
-{
-    pub fn new(addr_store: Arc<A>, auth_provider: Arc<AP>, sub_store: Arc<S>) -> Self {
-        Self {
-            addr_store,
-            auth_provider,
-            sub_store,
-        }
-    }
-}
+mod service;
+pub use service::*;
+mod prop;
+pub use prop::*;
 
 #[derive(Debug, Clone)]
 pub struct PrincipalResource {
@@ -56,34 +21,6 @@ impl ResourceName for PrincipalResource {
     }
 }
 
-#[derive(XmlDeserialize, XmlSerialize, PartialEq, Clone)]
-pub struct AddressbookHomeSet(#[xml(ty = "untagged", flatten)] Vec<HrefElement>);
-
-#[derive(XmlDeserialize, XmlSerialize, PartialEq, Clone, EnumVariants, PropName)]
-#[xml(unit_variants_ident = "PrincipalPropName")]
-pub enum PrincipalProp {
-    #[xml(ns = "rustical_dav::namespace::NS_DAV")]
-    Displayname(String),
-
-    // WebDAV Access Control (RFC 3744)
-    #[xml(rename = b"principal-URL")]
-    #[xml(ns = "rustical_dav::namespace::NS_DAV")]
-    PrincipalUrl(HrefElement),
-
-    // CardDAV (RFC 6352)
-    #[xml(ns = "rustical_dav::namespace::NS_CARDDAV")]
-    AddressbookHomeSet(AddressbookHomeSet),
-    #[xml(ns = "rustical_dav::namespace::NS_CARDDAV")]
-    PrincipalAddress(Option<HrefElement>),
-}
-
-#[derive(XmlDeserialize, XmlSerialize, PartialEq, Clone, EnumVariants, PropName)]
-#[xml(unit_variants_ident = "PrincipalPropWrapperName", untagged)]
-pub enum PrincipalPropWrapper {
-    Principal(PrincipalProp),
-    Common(CommonPropertiesProp),
-}
-
 impl Resource for PrincipalResource {
     type Prop = PrincipalPropWrapper;
     type Error = Error;
@@ -145,55 +82,3 @@ impl Resource for PrincipalResource {
         ))
     }
 }
-
-#[async_trait]
-impl<A: AddressbookStore, AP: AuthenticationProvider, S: SubscriptionStore> ResourceService
-    for PrincipalResourceService<A, AP, S>
-{
-    type PathComponents = (String,);
-    type MemberType = AddressbookResource;
-    type Resource = PrincipalResource;
-    type Error = Error;
-    type Principal = User;
-    type PrincipalUri = CardDavPrincipalUri;
-
-    const DAV_HEADER: &str = "1, 3, access-control, addressbook";
-
-    async fn get_resource(
-        &self,
-        (principal,): &Self::PathComponents,
-    ) -> Result<Self::Resource, Self::Error> {
-        let user = self
-            .auth_provider
-            .get_principal(principal)
-            .await?
-            .ok_or(crate::Error::NotFound)?;
-        Ok(PrincipalResource { principal: user })
-    }
-
-    async fn get_members(
-        &self,
-        (principal,): &Self::PathComponents,
-    ) -> Result<Vec<Self::MemberType>, Self::Error> {
-        let addressbooks = self.addr_store.get_addressbooks(principal).await?;
-        Ok(addressbooks
-            .into_iter()
-            .map(AddressbookResource::from)
-            .collect())
-    }
-
-    fn axum_router<State: Send + Sync + Clone + 'static>(self) -> Router<State> {
-        Router::new()
-            .nest(
-                "/{addressbook_id}",
-                AddressbookResourceService::new(self.addr_store.clone(), self.sub_store.clone())
-                    .axum_router(),
-            )
-            .route_service("/", self.axum_service())
-    }
-}
-
-impl<A: AddressbookStore, AP: AuthenticationProvider, S: SubscriptionStore> AxumMethods
-    for PrincipalResourceService<A, AP, S>
-{
-}

crates/carddav/src/principal/prop.rs

@@ -0,0 +1,30 @@
+use rustical_dav::{extensions::CommonPropertiesProp, xml::HrefElement};
+use rustical_xml::{EnumVariants, PropName, XmlDeserialize, XmlSerialize};
+
+#[derive(XmlDeserialize, XmlSerialize, PartialEq, Clone)]
+pub struct AddressbookHomeSet(#[xml(ty = "untagged", flatten)] pub(super) Vec<HrefElement>);
+
+#[derive(XmlDeserialize, XmlSerialize, PartialEq, Clone, EnumVariants, PropName)]
+#[xml(unit_variants_ident = "PrincipalPropName")]
+pub enum PrincipalProp {
+    #[xml(ns = "rustical_dav::namespace::NS_DAV")]
+    Displayname(String),
+
+    // WebDAV Access Control (RFC 3744)
+    #[xml(rename = b"principal-URL")]
+    #[xml(ns = "rustical_dav::namespace::NS_DAV")]
+    PrincipalUrl(HrefElement),
+
+    // CardDAV (RFC 6352)
+    #[xml(ns = "rustical_dav::namespace::NS_CARDDAV")]
+    AddressbookHomeSet(AddressbookHomeSet),
+    #[xml(ns = "rustical_dav::namespace::NS_CARDDAV")]
+    PrincipalAddress(Option<HrefElement>),
+}
+
+#[derive(XmlDeserialize, XmlSerialize, PartialEq, Clone, EnumVariants, PropName)]
+#[xml(unit_variants_ident = "PrincipalPropWrapperName", untagged)]
+pub enum PrincipalPropWrapper {
+    Principal(PrincipalProp),
+    Common(CommonPropertiesProp),
+}

crates/carddav/src/principal/service.rs

@@ -0,0 +1,96 @@
+use crate::addressbook::AddressbookResourceService;
+use crate::addressbook::resource::AddressbookResource;
+use crate::principal::PrincipalResource;
+use crate::{CardDavPrincipalUri, Error};
+use async_trait::async_trait;
+use axum::Router;
+use rustical_dav::resource::{AxumMethods, ResourceService};
+use rustical_store::auth::{AuthenticationProvider, User};
+use rustical_store::{AddressbookStore, SubscriptionStore};
+use std::sync::Arc;
+
+pub struct PrincipalResourceService<
+    A: AddressbookStore,
+    AP: AuthenticationProvider,
+    S: SubscriptionStore,
+> {
+    addr_store: Arc<A>,
+    auth_provider: Arc<AP>,
+    sub_store: Arc<S>,
+}
+
+impl<A: AddressbookStore, AP: AuthenticationProvider, S: SubscriptionStore> Clone
+    for PrincipalResourceService<A, AP, S>
+{
+    fn clone(&self) -> Self {
+        Self {
+            addr_store: self.addr_store.clone(),
+            auth_provider: self.auth_provider.clone(),
+            sub_store: self.sub_store.clone(),
+        }
+    }
+}
+
+impl<A: AddressbookStore, AP: AuthenticationProvider, S: SubscriptionStore>
+    PrincipalResourceService<A, AP, S>
+{
+    pub fn new(addr_store: Arc<A>, auth_provider: Arc<AP>, sub_store: Arc<S>) -> Self {
+        Self {
+            addr_store,
+            auth_provider,
+            sub_store,
+        }
+    }
+}
+
+#[async_trait]
+impl<A: AddressbookStore, AP: AuthenticationProvider, S: SubscriptionStore> ResourceService
+    for PrincipalResourceService<A, AP, S>
+{
+    type PathComponents = (String,);
+    type MemberType = AddressbookResource;
+    type Resource = PrincipalResource;
+    type Error = Error;
+    type Principal = User;
+    type PrincipalUri = CardDavPrincipalUri;
+
+    const DAV_HEADER: &str = "1, 3, access-control, addressbook";
+
+    async fn get_resource(
+        &self,
+        (principal,): &Self::PathComponents,
+    ) -> Result<Self::Resource, Self::Error> {
+        let user = self
+            .auth_provider
+            .get_principal(principal)
+            .await?
+            .ok_or(crate::Error::NotFound)?;
+        Ok(PrincipalResource { principal: user })
+    }
+
+    async fn get_members(
+        &self,
+        (principal,): &Self::PathComponents,
+    ) -> Result<Vec<Self::MemberType>, Self::Error> {
+        let addressbooks = self.addr_store.get_addressbooks(principal).await?;
+        Ok(addressbooks
+            .into_iter()
+            .map(AddressbookResource::from)
+            .collect())
+    }
+
+    fn axum_router<State: Send + Sync + Clone + 'static>(self) -> Router<State> {
+        Router::new()
+            .nest(
+                "/{addressbook_id}",
+                AddressbookResourceService::new(self.addr_store.clone(), self.sub_store.clone())
+                    .axum_router(),
+            )
+            .route_service("/", self.axum_service())
+    }
+}
+
+impl<A: AddressbookStore, AP: AuthenticationProvider, S: SubscriptionStore> AxumMethods
+    for PrincipalResourceService<A, AP, S>
+{
+}