birthday calendar, lots of refactoring

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

@@ -1,6 +1,5 @@
 use crate::{
     calendar_object::resource::{CalendarObjectProp, CalendarObjectResource},
-    principal::PrincipalResource,
     Error,
 };
 use actix_web::{
@@ -27,13 +26,12 @@ pub(crate) struct CalendarMultigetRequest {
 
 pub async fn get_objects_calendar_multiget<C: CalendarStore + ?Sized>(
     cal_query: &CalendarMultigetRequest,
-    principal_url: &str,
+    path: &str,
     principal: &str,
     cal_id: &str,
     store: &C,
 ) -> Result<(Vec<CalendarObject>, Vec<String>), Error> {
-    let resource_def =
+    let resource_def = ResourceDef::prefix(path).join(&ResourceDef::new("/{object_id}"));
-        ResourceDef::prefix(principal_url).join(&ResourceDef::new("/{cal_id}/{object_id}"));
 
     let mut result = vec![];
     let mut not_found = vec![];
@@ -43,9 +41,6 @@ pub async fn get_objects_calendar_multiget<C: CalendarStore + ?Sized>(
         if !resource_def.capture_match_info(&mut path) {
             not_found.push(href.to_owned());
         };
-        if path.get("cal_id").unwrap() != cal_id {
-            not_found.push(href.to_owned());
-        }
         let object_id = path.get("object_id").unwrap();
         match store.get_object(principal, cal_id, object_id).await {
             Ok(object) => result.push(object),
@@ -66,9 +61,8 @@ pub async fn handle_calendar_multiget<C: CalendarStore + ?Sized>(
     cal_store: &C,
 ) -> Result<MultistatusElement<EitherProp<CalendarObjectProp, CommonPropertiesProp>, String>, Error>
 {
-    let principal_url = PrincipalResource::get_url(req.resource_map(), vec![principal]).unwrap();
     let (objects, not_found) =
-        get_objects_calendar_multiget(&cal_multiget, &principal_url, principal, cal_id, cal_store)
+        get_objects_calendar_multiget(&cal_multiget, req.path(), principal, cal_id, cal_store)
             .await?;
 
     let props = match cal_multiget.prop {

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

@@ -110,8 +110,7 @@ impl CompFilterElement {
         if self
             .comp_filter
             .iter()
-            .map(|filter| filter.matches(cal_object))
+            .all(|filter| filter.matches(cal_object))
-            .all(|x| x)
         {
             return true;
         }
@@ -215,11 +214,7 @@ pub async fn handle_calendar_query<C: CalendarStore + ?Sized>(
 
     let mut responses = Vec::new();
     for object in objects {
-        let path = CalendarObjectResource::get_url(
+        let path = format!("{}/{}", req.path().trim_end_matches('/'), object.get_id());
-            req.resource_map(),
-            vec![principal, cal_id, object.get_id()],
-        )
-        .unwrap();
         responses.push(
             CalendarObjectResource {
                 object,

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

@@ -86,11 +86,7 @@ pub async fn handle_sync_collection<C: CalendarStore + ?Sized>(
 
     let mut responses = Vec::new();
     for object in new_objects {
-        let path = CalendarObjectResource::get_url(
+        let path = format!("{}/{}", req.path().trim_end_matches('/'), object.get_id());
-            req.resource_map(),
-            vec![principal, cal_id, &object.get_id()],
-        )
-        .unwrap();
         responses.push(
             CalendarObjectResource {
                 object,
@@ -101,11 +97,7 @@ pub async fn handle_sync_collection<C: CalendarStore + ?Sized>(
     }
 
     for object_id in deleted_objects {
-        let path = CalendarObjectResource::get_url(
+        let path = format!("{}/{}", req.path().trim_end_matches('/'), object_id);
-            req.resource_map(),
-            vec![principal, cal_id, &object_id],
-        )
-        .unwrap();
         responses.push(ResponseElement {
             href: path,
             status: Some(StatusCode::NOT_FOUND),

crates/caldav/src/calendar/resource.rs

@@ -22,16 +22,6 @@ use std::str::FromStr;
 use std::sync::Arc;
 use strum::{EnumDiscriminants, EnumString, IntoStaticStr, VariantNames};
 
-pub struct CalendarResourceService<C: CalendarStore + ?Sized> {
-    cal_store: Arc<C>,
-}
-
-impl<C: CalendarStore + ?Sized> CalendarResourceService<C> {
-    pub fn new(cal_store: Arc<C>) -> Self {
-        Self { cal_store }
-    }
-}
-
 #[derive(XmlDeserialize, XmlSerialize, PartialEq, EnumDiscriminants, Clone)]
 #[strum_discriminants(
     name(CalendarPropName),
@@ -122,7 +112,7 @@ impl Resource for CalendarResource {
 
     fn get_prop(
         &self,
-        rmap: &ResourceMap,
+        _rmap: &ResourceMap,
         _user: &User,
         prop: &Self::PropName,
     ) -> Result<Self::Prop, Self::Error> {
@@ -153,8 +143,9 @@ impl Resource for CalendarResource {
             CalendarPropName::Transports => CalendarProp::Transports(Default::default()),
             CalendarPropName::Topic => {
                 // TODO: Add salt since this could be public
-                let url =
+                // let url =
-                    CalendarResource::get_url(rmap, [&self.cal.principal, &self.cal.id]).unwrap();
+                //     CalendarResource::get_url(rmap, [&self.cal.principal, &self.cal.id]).unwrap();
+                let url = "TODO!".to_owned();
                 let mut hasher = Sha256::new();
                 hasher.update(url);
                 let topic = format!("{:x}", hasher.finalize());
@@ -263,11 +254,6 @@ impl Resource for CalendarResource {
         }
     }
 
-    #[inline]
-    fn resource_name() -> &'static str {
-        "caldav_calendar"
-    }
-
     fn get_owner(&self) -> Option<&str> {
         Some(&self.cal.principal)
     }
@@ -281,6 +267,16 @@ impl Resource for CalendarResource {
     }
 }
 
+pub struct CalendarResourceService<C: CalendarStore + ?Sized> {
+    cal_store: Arc<C>,
+}
+
+impl<C: CalendarStore + ?Sized> CalendarResourceService<C> {
+    pub fn new(cal_store: Arc<C>) -> Self {
+        Self { cal_store }
+    }
+}
+
 #[async_trait(?Send)]
 impl<C: CalendarStore + ?Sized> ResourceService for CalendarResourceService<C> {
     type MemberType = CalendarObjectResource;
@@ -292,11 +288,7 @@ impl<C: CalendarStore + ?Sized> ResourceService for CalendarResourceService<C> {
         &self,
         (principal, cal_id): &Self::PathComponents,
     ) -> Result<Self::Resource, Error> {
-        let calendar = self
+        let calendar = self.cal_store.get_calendar(principal, cal_id).await?;
-            .cal_store
-            .get_calendar(principal, cal_id)
-            .await
-            .map_err(|_e| Error::NotFound)?;
         Ok(CalendarResource {
             cal: calendar,
             read_only: self.cal_store.is_read_only(),
@@ -306,7 +298,6 @@ impl<C: CalendarStore + ?Sized> ResourceService for CalendarResourceService<C> {
     async fn get_members(
         &self,
         (principal, cal_id): &Self::PathComponents,
-        rmap: &ResourceMap,
     ) -> Result<Vec<(String, Self::MemberType)>, Self::Error> {
         Ok(self
             .cal_store
@@ -315,8 +306,7 @@ impl<C: CalendarStore + ?Sized> ResourceService for CalendarResourceService<C> {
             .into_iter()
             .map(|object| {
                 (
-                    CalendarObjectResource::get_url(rmap, vec![principal, cal_id, object.get_id()])
+                    object.get_id().to_string(),
-                        .unwrap(),
                     CalendarObjectResource {
                         object,
                         principal: principal.to_owned(),

crates/caldav/src/calendar_object/resource.rs

@@ -75,11 +75,6 @@ impl Resource for CalendarObjectResource {
         })
     }
 
-    #[inline]
-    fn resource_name() -> &'static str {
-        "caldav_calendar_object"
-    }
-
     fn get_owner(&self) -> Option<&str> {
         Some(&self.principal)
     }

crates/caldav/src/calendar_set/mod.rs

@@ -0,0 +1,114 @@
+use crate::calendar::resource::CalendarResource;
+use crate::principal::PrincipalResource;
+use crate::Error;
+use actix_web::dev::ResourceMap;
+use async_trait::async_trait;
+use rustical_dav::privileges::UserPrivilegeSet;
+use rustical_dav::resource::{NamedRoute, Resource, ResourceService};
+use rustical_dav::xml::{HrefElement, Resourcetype, ResourcetypeInner};
+use rustical_store::auth::User;
+use rustical_store::CalendarStore;
+use rustical_xml::{XmlDeserialize, XmlSerialize};
+use std::sync::Arc;
+use strum::{EnumDiscriminants, EnumString, IntoStaticStr, VariantNames};
+
+#[derive(Clone)]
+pub struct CalendarSetResource {
+    pub(crate) principal: String,
+}
+
+#[derive(XmlDeserialize, XmlSerialize, PartialEq, EnumDiscriminants, Clone)]
+#[strum_discriminants(
+    name(PrincipalPropName),
+    derive(EnumString, VariantNames, IntoStaticStr),
+    strum(serialize_all = "kebab-case")
+)]
+pub enum PrincipalProp {
+    // WebDAV Access Control (RFC 3744)
+    #[strum_discriminants(strum(serialize = "principal-URL"))]
+    #[xml(ns = "rustical_dav::namespace::NS_DAV")]
+    PrincipalUrl(HrefElement),
+}
+
+impl Resource for CalendarSetResource {
+    type PropName = PrincipalPropName;
+    type Prop = PrincipalProp;
+    type Error = Error;
+    type PrincipalResource = PrincipalResource;
+
+    fn get_resourcetype(&self) -> Resourcetype {
+        Resourcetype(&[ResourcetypeInner(
+            rustical_dav::namespace::NS_DAV,
+            "collection",
+        )])
+    }
+
+    fn get_prop(
+        &self,
+        rmap: &ResourceMap,
+        _user: &User,
+        prop: &Self::PropName,
+    ) -> Result<Self::Prop, Self::Error> {
+        let principal_href = HrefElement::new(
+            Self::PrincipalResource::get_url(rmap, vec![&self.principal]).unwrap(),
+        );
+
+        Ok(match prop {
+            PrincipalPropName::PrincipalUrl => PrincipalProp::PrincipalUrl(principal_href),
+        })
+    }
+
+    fn get_owner(&self) -> Option<&str> {
+        Some(&self.principal)
+    }
+
+    fn get_user_privileges(&self, user: &User) -> Result<UserPrivilegeSet, Self::Error> {
+        Ok(UserPrivilegeSet::owner_only(self.principal == user.id))
+    }
+}
+
+pub struct CalendarSetResourceService<C: CalendarStore + ?Sized> {
+    cal_store: Arc<C>,
+}
+
+impl<C: CalendarStore + ?Sized> CalendarSetResourceService<C> {
+    pub fn new(cal_store: Arc<C>) -> Self {
+        Self { cal_store }
+    }
+}
+
+#[async_trait(?Send)]
+impl<C: CalendarStore + ?Sized> ResourceService for CalendarSetResourceService<C> {
+    type PathComponents = (String,);
+    type MemberType = CalendarResource;
+    type Resource = CalendarSetResource;
+    type Error = Error;
+
+    async fn get_resource(
+        &self,
+        (principal,): &Self::PathComponents,
+    ) -> Result<Self::Resource, Self::Error> {
+        Ok(CalendarSetResource {
+            principal: principal.to_owned(),
+        })
+    }
+
+    async fn get_members(
+        &self,
+        (principal,): &Self::PathComponents,
+    ) -> Result<Vec<(String, Self::MemberType)>, Self::Error> {
+        let calendars = self.cal_store.get_calendars(principal).await?;
+        Ok(calendars
+            .into_iter()
+            .map(|cal| {
+                (
+                    cal.id.to_owned(),
+                    CalendarResource {
+                        cal,
+                        read_only: self.cal_store.is_read_only(),
+                    },
+                )
+            })
+            .collect())
+    }
+}

crates/caldav/src/lib.rs

@@ -6,15 +6,17 @@ use actix_web::web::{self, Data};
 use actix_web::HttpResponse;
 use calendar::resource::CalendarResourceService;
 use calendar_object::resource::CalendarObjectResourceService;
+use calendar_set::CalendarSetResourceService;
 use principal::{PrincipalResource, PrincipalResourceService};
-use rustical_dav::resource::ResourceService;
+use rustical_dav::resource::{NamedRoute, ResourceService, ResourceServiceRoute};
 use rustical_dav::resources::RootResourceService;
 use rustical_store::auth::{AuthenticationMiddleware, AuthenticationProvider};
-use rustical_store::CalendarStore;
+use rustical_store::{AddressbookStore, CalendarStore, ContactBirthdayStore};
 use std::sync::Arc;
 
 pub mod calendar;
 pub mod calendar_object;
+pub mod calendar_set;
 pub mod error;
 pub mod principal;
 
@@ -24,11 +26,17 @@ pub fn configure_well_known(cfg: &mut web::ServiceConfig, caldav_root: String) {
     cfg.service(web::redirect("/caldav", caldav_root).permanent());
 }
 
-pub fn configure_dav<AP: AuthenticationProvider, C: CalendarStore + ?Sized>(
+pub fn configure_dav<
+    AP: AuthenticationProvider,
+    AS: AddressbookStore + ?Sized,
+    C: CalendarStore + ?Sized,
+>(
     cfg: &mut web::ServiceConfig,
     auth_provider: Arc<AP>,
     store: Arc<C>,
+    addr_store: Arc<AS>,
 ) {
+    let birthday_store = Arc::new(ContactBirthdayStore::new(addr_store));
     cfg.service(
         web::scope("")
             .wrap(AuthenticationMiddleware::new(auth_provider))
@@ -53,24 +61,36 @@ pub fn configure_dav<AP: AuthenticationProvider, C: CalendarStore + ?Sized>(
                 }),
             )
             .app_data(Data::from(store.clone()))
+            .app_data(Data::from(birthday_store.clone()))
             .service(RootResourceService::<PrincipalResource>::default().actix_resource())
             .service(
                 web::scope("/user").service(
                     web::scope("/{principal}")
-                        .service(PrincipalResourceService::<C>::new(store.clone()).actix_resource())
+                        .service(PrincipalResourceService(&[
+                            "calendar", "birthdays"
+                        ]).actix_resource().name(PrincipalResource::route_name()))
+                        .service(web::scope("/calendar")
+                            .service(CalendarSetResourceService::new(store.clone()).actix_resource())
                             .service(
                                 web::scope("/{calendar}")
                                     .service(
-                                    CalendarResourceService::<C>::new(store.clone())
+                                        ResourceServiceRoute(CalendarResourceService::new(store.clone()))
-                                        .actix_resource(),
                                     )
+                                        .service(web::scope("/{object}").service(CalendarObjectResourceService::new(store.clone()).actix_resource()
+                                    ))
+                            )
+                        )
+                        .service(web::scope("/birthdays")
+                            .service(CalendarSetResourceService::new(birthday_store.clone()).actix_resource())
                             .service(
-                                    web::scope("/{object}").service(
+                                web::scope("/{calendar}")
-                                        CalendarObjectResourceService::<C>::new(store.clone())
+                                    .service(
-                                            .actix_resource(),
+                                        ResourceServiceRoute(CalendarResourceService::new(birthday_store.clone()))
-                                    ),
+                                    )
-                                ),
+                                        .service(web::scope("/{object}").service(CalendarObjectResourceService::new(birthday_store.clone()).actix_resource()
-                        ),
+                                    ))
+                            )
+                        )
                 ),
             ),
     );

crates/caldav/src/principal/mod.rs

@@ -1,31 +1,23 @@
-use crate::calendar::resource::CalendarResource;
+use crate::calendar_set::CalendarSetResource;
 use crate::Error;
 use actix_web::dev::ResourceMap;
 use async_trait::async_trait;
 use rustical_dav::privileges::UserPrivilegeSet;
-use rustical_dav::resource::{Resource, ResourceService};
+use rustical_dav::resource::{NamedRoute, Resource, ResourceService};
 use rustical_dav::xml::{HrefElement, Resourcetype, ResourcetypeInner};
 use rustical_store::auth::User;
-use rustical_store::CalendarStore;
 use rustical_xml::{XmlDeserialize, XmlSerialize};
-use std::sync::Arc;
 use strum::{EnumDiscriminants, EnumString, IntoStaticStr, VariantNames};
 
-pub struct PrincipalResourceService<C: CalendarStore + ?Sized> {
-    cal_store: Arc<C>,
-}
-
-impl<C: CalendarStore + ?Sized> PrincipalResourceService<C> {
-    pub fn new(cal_store: Arc<C>) -> Self {
-        Self { cal_store }
-    }
-}
-
 #[derive(Clone)]
 pub struct PrincipalResource {
     principal: String,
+    home_set: &'static [&'static str],
 }
 
+#[derive(XmlDeserialize, XmlSerialize, PartialEq, Clone)]
+pub struct CalendarHomeSet(#[xml(ty = "untagged", flatten)] Vec<HrefElement>);
+
 #[derive(XmlDeserialize, XmlSerialize, PartialEq, EnumDiscriminants, Clone)]
 #[strum_discriminants(
     name(PrincipalPropName),
@@ -40,7 +32,7 @@ pub enum PrincipalProp {
 
     // CalDAV (RFC 4791)
     #[xml(ns = "rustical_dav::namespace::NS_CALDAV")]
-    CalendarHomeSet(HrefElement),
+    CalendarHomeSet(CalendarHomeSet),
     #[xml(ns = "rustical_dav::namespace::NS_CALDAV")]
     CalendarUserAddressSet(HrefElement),
 }
@@ -51,6 +43,12 @@ impl PrincipalResource {
     }
 }
 
+impl NamedRoute for PrincipalResource {
+    fn route_name() -> &'static str {
+        "caldav_principal"
+    }
+}
+
 impl Resource for PrincipalResource {
     type PropName = PrincipalPropName;
     type Prop = PrincipalProp;
@@ -70,22 +68,23 @@ impl Resource for PrincipalResource {
         _user: &User,
         prop: &Self::PropName,
     ) -> Result<Self::Prop, Self::Error> {
-        let principal_href = HrefElement::new(Self::get_url(rmap, vec![&self.principal]).unwrap());
+        let principal_url = Self::get_url(rmap, vec![&self.principal]).unwrap();
+        let home_set = CalendarHomeSet(
+            self.home_set
+                .iter()
+                .map(|&home_name| format!("{}/{}", principal_url, home_name).into())
+                .collect(),
+        );
 
         Ok(match prop {
-            PrincipalPropName::PrincipalUrl => PrincipalProp::PrincipalUrl(principal_href),
+            PrincipalPropName::PrincipalUrl => PrincipalProp::PrincipalUrl(principal_url.into()),
-            PrincipalPropName::CalendarHomeSet => PrincipalProp::CalendarHomeSet(principal_href),
+            PrincipalPropName::CalendarHomeSet => PrincipalProp::CalendarHomeSet(home_set),
             PrincipalPropName::CalendarUserAddressSet => {
-                PrincipalProp::CalendarUserAddressSet(principal_href)
+                PrincipalProp::CalendarUserAddressSet(principal_url.into())
             }
         })
     }
 
-    #[inline]
-    fn resource_name() -> &'static str {
-        "caldav_principal"
-    }
-
     fn get_owner(&self) -> Option<&str> {
         Some(&self.principal)
     }
@@ -95,10 +94,12 @@ impl Resource for PrincipalResource {
     }
 }
 
+pub struct PrincipalResourceService(pub &'static [&'static str]);
+
 #[async_trait(?Send)]
-impl<C: CalendarStore + ?Sized> ResourceService for PrincipalResourceService<C> {
+impl ResourceService for PrincipalResourceService {
     type PathComponents = (String,);
-    type MemberType = CalendarResource;
+    type MemberType = CalendarSetResource;
     type Resource = PrincipalResource;
     type Error = Error;
 
@@ -108,23 +109,22 @@ impl<C: CalendarStore + ?Sized> ResourceService for PrincipalResourceService<C>
     ) -> Result<Self::Resource, Self::Error> {
         Ok(PrincipalResource {
             principal: principal.to_owned(),
+            home_set: self.0,
         })
     }
 
     async fn get_members(
         &self,
         (principal,): &Self::PathComponents,
-        rmap: &ResourceMap,
     ) -> Result<Vec<(String, Self::MemberType)>, Self::Error> {
-        let calendars = self.cal_store.get_calendars(principal).await?;
+        Ok(self
-        Ok(calendars
+            .0
-            .into_iter()
+            .iter()
-            .map(|cal| {
+            .map(|&set_name| {
                 (
-                    CalendarResource::get_url(rmap, vec![principal, &cal.id]).unwrap(),
+                    set_name.to_string(),
-                    CalendarResource {
+                    CalendarSetResource {
-                        cal,
+                        principal: principal.to_owned(),
-                        read_only: self.cal_store.is_read_only(),
                     },
                 )
             })

crates/carddav/src/address_object/resource.rs

@@ -76,11 +76,6 @@ impl Resource for AddressObjectResource {
         })
     }
 
-    #[inline]
-    fn resource_name() -> &'static str {
-        "carddav_address_object"
-    }
-
     fn get_owner(&self) -> Option<&str> {
         Some(&self.principal)
     }

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

@@ -1,6 +1,5 @@
 use crate::{
     address_object::resource::{AddressObjectProp, AddressObjectResource},
-    principal::PrincipalResource,
     Error,
 };
 use actix_web::{
@@ -10,8 +9,7 @@ use actix_web::{
 };
 use rustical_dav::{
     resource::{CommonPropertiesProp, EitherProp, Resource},
-    xml::{multistatus::ResponseElement, MultistatusElement},
+    xml::{multistatus::ResponseElement, MultistatusElement, PropElement, PropfindType},
-    xml::{PropElement, PropfindType},
 };
 use rustical_store::{auth::User, AddressObject, AddressbookStore};
 use rustical_xml::XmlDeserialize;
@@ -27,13 +25,12 @@ pub struct AddressbookMultigetRequest {
 
 pub async fn get_objects_addressbook_multiget<AS: AddressbookStore + ?Sized>(
     addressbook_multiget: &AddressbookMultigetRequest,
-    principal_url: &str,
+    path: &str,
     principal: &str,
     addressbook_id: &str,
     store: &AS,
 ) -> Result<(Vec<AddressObject>, Vec<String>), Error> {
-    let resource_def =
+    let resource_def = ResourceDef::prefix(path).join(&ResourceDef::new("/{object_id}"));
-        ResourceDef::prefix(principal_url).join(&ResourceDef::new("/{addressbook_id}/{object_id}"));
 
     let mut result = vec![];
     let mut not_found = vec![];
@@ -67,14 +64,8 @@ pub async fn handle_addressbook_multiget<AS: AddressbookStore + ?Sized>(
     addr_store: &AS,
 ) -> Result<MultistatusElement<EitherProp<AddressObjectProp, CommonPropertiesProp>, String>, Error>
 {
-    let principal_url = PrincipalResource::get_url(req.resource_map(), vec![principal]).unwrap();
+    let (objects, not_found) =
-    let (objects, not_found) = get_objects_addressbook_multiget(
+        get_objects_addressbook_multiget(&addr_multiget, req.path(), principal, cal_id, addr_store)
-        &addr_multiget,
-        &principal_url,
-        principal,
-        cal_id,
-        addr_store,
-    )
             .await?;
 
     let props = match addr_multiget.prop {

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

@@ -83,11 +83,7 @@ pub async fn handle_sync_collection<AS: AddressbookStore + ?Sized>(
 
     let mut responses = Vec::new();
     for object in new_objects {
-        let path = AddressObjectResource::get_url(
+        let path = format!("{}/{}", req.path().trim_end_matches('/'), object.get_id());
-            req.resource_map(),
-            vec![principal, addressbook_id, &object.get_id()],
-        )
-        .unwrap();
         responses.push(
             AddressObjectResource {
                 object,
@@ -98,11 +94,7 @@ pub async fn handle_sync_collection<AS: AddressbookStore + ?Sized>(
     }
 
     for object_id in deleted_objects {
-        let path = AddressObjectResource::get_url(
+        let path = format!("{}/{}", req.path().trim_end_matches('/'), object_id);
-            req.resource_map(),
-            vec![principal, addressbook_id, &object_id],
-        )
-        .unwrap();
         responses.push(ResponseElement {
             href: path,
             status: Some(StatusCode::NOT_FOUND),

crates/carddav/src/addressbook/resource.rs

@@ -143,11 +143,6 @@ impl Resource for AddressbookResource {
         }
     }
 
-    #[inline]
-    fn resource_name() -> &'static str {
-        "carddav_addressbook"
-    }
-
     fn get_owner(&self) -> Option<&str> {
         Some(&self.0.principal)
     }
@@ -179,7 +174,6 @@ impl<AS: AddressbookStore + ?Sized> ResourceService for AddressbookResourceServi
     async fn get_members(
         &self,
         (principal, addressbook_id): &Self::PathComponents,
-        rmap: &ResourceMap,
     ) -> Result<Vec<(String, Self::MemberType)>, Self::Error> {
         Ok(self
             .addr_store
@@ -188,11 +182,7 @@ impl<AS: AddressbookStore + ?Sized> ResourceService for AddressbookResourceServi
             .into_iter()
             .map(|object| {
                 (
-                    AddressObjectResource::get_url(
+                    object.get_id().to_string(),
-                        rmap,
-                        vec![principal, addressbook_id, object.get_id()],
-                    )
-                    .unwrap(),
                     AddressObjectResource {
                         object,
                         principal: principal.to_owned(),

crates/carddav/src/lib.rs

@@ -12,7 +12,7 @@ use address_object::resource::AddressObjectResourceService;
 use addressbook::resource::AddressbookResourceService;
 pub use error::Error;
 use principal::{PrincipalResource, PrincipalResourceService};
-use rustical_dav::resource::ResourceService;
+use rustical_dav::resource::{NamedRoute, ResourceService};
 use rustical_dav::resources::RootResourceService;
 use rustical_store::{
     auth::{AuthenticationMiddleware, AuthenticationProvider},
@@ -62,7 +62,11 @@ pub fn configure_dav<AP: AuthenticationProvider, A: AddressbookStore + ?Sized>(
             .service(
                 web::scope("/user").service(
                     web::scope("/{principal}")
-                        .service(PrincipalResourceService::<A>::new(store.clone()).actix_resource())
+                        .service(
+                            PrincipalResourceService::new(store.clone())
+                                .actix_resource()
+                                .name(PrincipalResource::route_name()),
+                        )
                         .service(
                             web::scope("/{addressbook}")
                                 .service(

crates/carddav/src/principal/mod.rs

@@ -3,7 +3,7 @@ use crate::Error;
 use actix_web::dev::ResourceMap;
 use async_trait::async_trait;
 use rustical_dav::privileges::UserPrivilegeSet;
-use rustical_dav::resource::{Resource, ResourceService};
+use rustical_dav::resource::{NamedRoute, Resource, ResourceService};
 use rustical_dav::xml::{HrefElement, Resourcetype, ResourcetypeInner};
 use rustical_store::auth::User;
 use rustical_store::AddressbookStore;
@@ -52,6 +52,12 @@ impl PrincipalResource {
     }
 }
 
+impl NamedRoute for PrincipalResource {
+    fn route_name() -> &'static str {
+        "carddav_principal"
+    }
+}
+
 impl Resource for PrincipalResource {
     type PropName = PrincipalPropName;
     type Prop = PrincipalProp;
@@ -82,11 +88,6 @@ impl Resource for PrincipalResource {
         })
     }
 
-    #[inline]
-    fn resource_name() -> &'static str {
-        "carddav_principal"
-    }
-
     fn get_owner(&self) -> Option<&str> {
         Some(&self.principal)
     }
@@ -115,17 +116,11 @@ impl<A: AddressbookStore + ?Sized> ResourceService for PrincipalResourceService<
     async fn get_members(
         &self,
         (principal,): &Self::PathComponents,
-        rmap: &ResourceMap,
     ) -> Result<Vec<(String, Self::MemberType)>, Self::Error> {
         let addressbooks = self.addr_store.get_addressbooks(principal).await?;
         Ok(addressbooks
             .into_iter()
-            .map(|addressbook| {
+            .map(|addressbook| (addressbook.id.to_owned(), addressbook.into()))
-                (
-                    AddressbookResource::get_url(rmap, vec![principal, &addressbook.id]).unwrap(),
-                    addressbook.into(),
-                )
-            })
             .collect())
     }
 }

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

@@ -61,11 +61,13 @@ pub(crate) async fn route_propfind<R: ResourceService>(
 
     let mut member_responses = Vec::new();
     if depth != Depth::Zero {
-        for (path, member) in resource_service
+        for (subpath, member) in resource_service.get_members(&path).await? {
-            .get_members(&path, req.resource_map())
+            member_responses.push(member.propfind(
-            .await?
+                &format!("{}/{}", req.path().trim_end_matches('/'), subpath),
-        {
+                &props,
-            member_responses.push(member.propfind(&path, &props, &user, req.resource_map())?);
+                &user,
+                req.resource_map(),
+            )?);
         }
     }
 

crates/dav/src/resource/mod.rs

@@ -4,8 +4,6 @@ use crate::xml::{multistatus::ResponseElement, TagList};
 use crate::xml::{HrefElement, Resourcetype};
 use crate::Error;
 use actix_web::dev::ResourceMap;
-use actix_web::error::UrlGenerationError;
-use actix_web::test::TestRequest;
 use actix_web::{http::StatusCode, ResponseError};
 use itertools::Itertools;
 pub use resource_service::ResourceService;
@@ -17,6 +15,8 @@ use strum::{EnumString, VariantNames};
 mod methods;
 mod resource_service;
 
+pub use resource_service::*;
+
 pub trait ResourceProp: XmlSerialize + XmlDeserialize {}
 impl<T: XmlSerialize + XmlDeserialize> ResourceProp for T {}
 
@@ -62,7 +62,7 @@ pub trait Resource: Clone + 'static {
     type PropName: ResourcePropName + From<Self::Prop> + Into<&'static str>;
     type Prop: ResourceProp + PartialEq + Clone;
     type Error: ResponseError + From<crate::Error>;
-    type PrincipalResource: Resource;
+    type PrincipalResource: Resource + NamedRoute;
 
     fn get_resourcetype(&self) -> Resourcetype;
 
@@ -115,27 +115,10 @@ pub trait Resource: Clone + 'static {
         Err(crate::Error::PropReadOnly)
     }
 
-    fn resource_name() -> &'static str;
-
     fn get_owner(&self) -> Option<&str> {
         None
     }
 
-    fn get_url<U, I>(rmap: &ResourceMap, elements: U) -> Result<String, UrlGenerationError>
-    where
-        U: IntoIterator<Item = I>,
-        I: AsRef<str>,
-    {
-        Ok(rmap
-            .url_for(
-                &TestRequest::default().to_http_request(),
-                Self::resource_name(),
-                elements,
-            )?
-            .path()
-            .to_owned())
-    }
-
     fn get_user_privileges(&self, user: &User) -> Result<UserPrivilegeSet, Self::Error>;
 
     fn propfind(

crates/dav/src/resource/resource_service.rs

@@ -1,9 +1,11 @@
-use std::str::FromStr;
+use actix_web::dev::{AppService, HttpServiceFactory};
-
+use actix_web::error::UrlGenerationError;
+use actix_web::test::TestRequest;
 use actix_web::web::Data;
 use actix_web::{dev::ResourceMap, http::Method, web, ResponseError};
 use async_trait::async_trait;
 use serde::Deserialize;
+use std::str::FromStr;
 
 use super::methods::{route_delete, route_propfind, route_proppatch};
 use super::Resource;
@@ -17,8 +19,7 @@ pub trait ResourceService: Sized + 'static {
 
     async fn get_members(
         &self,
-        _path: &Self::PathComponents,
+        _path_components: &Self::PathComponents,
-        _rmap: &ResourceMap,
     ) -> Result<Vec<(String, Self::MemberType)>, Self::Error> {
         Ok(vec![])
     }
@@ -42,17 +43,11 @@ pub trait ResourceService: Sized + 'static {
         Err(crate::Error::Unauthorized.into())
     }
 
-    #[inline]
-    fn resource_name() -> &'static str {
-        Self::Resource::resource_name()
-    }
-
     #[inline]
     fn actix_resource(self) -> actix_web::Resource {
         Self::actix_additional_routes(
             web::resource("")
                 .app_data(Data::new(self))
-                .name(Self::resource_name())
                 .route(
                     web::method(Method::from_str("PROPFIND").unwrap()).to(route_propfind::<Self>),
                 )
@@ -69,3 +64,30 @@ pub trait ResourceService: Sized + 'static {
         res
     }
 }
+
+pub trait NamedRoute {
+    fn route_name() -> &'static str;
+
+    fn get_url<U, I>(rmap: &ResourceMap, elements: U) -> Result<String, UrlGenerationError>
+    where
+        U: IntoIterator<Item = I>,
+        I: AsRef<str>,
+    {
+        Ok(rmap
+            .url_for(
+                &TestRequest::default().to_http_request(),
+                Self::route_name(),
+                elements,
+            )?
+            .path()
+            .to_owned())
+    }
+}
+
+pub struct ResourceServiceRoute<RS: ResourceService>(pub RS);
+
+impl<RS: ResourceService> HttpServiceFactory for ResourceServiceRoute<RS> {
+    fn register(self, config: &mut AppService) {
+        self.0.actix_resource().register(config);
+    }
+}

crates/dav/src/resources/root.rs

@@ -1,12 +1,11 @@
 use crate::privileges::UserPrivilegeSet;
-use crate::resource::{Resource, ResourceService};
+use crate::resource::{NamedRoute, Resource, ResourceService};
 use crate::xml::{Resourcetype, ResourcetypeInner};
 use actix_web::dev::ResourceMap;
 use async_trait::async_trait;
 use rustical_store::auth::User;
 use rustical_xml::{XmlDeserialize, XmlSerialize};
 use serde::Serialize;
-use std::any::type_name;
 use std::marker::PhantomData;
 use strum::{EnumString, IntoStaticStr, VariantNames};
 
@@ -32,7 +31,7 @@ impl From<RootResourceProp> for RootResourcePropName {
     }
 }
 
-impl<PR: Resource> Resource for RootResource<PR> {
+impl<PR: Resource + NamedRoute> Resource for RootResource<PR> {
     type PropName = RootResourcePropName;
     type Prop = RootResourceProp;
     type Error = PR::Error;
@@ -51,16 +50,12 @@ impl<PR: Resource> Resource for RootResource<PR> {
         unreachable!("we shouldn't end up here")
     }
 
-    #[inline]
-    fn resource_name() -> &'static str {
-        type_name::<Self>()
-    }
-
     fn get_user_privileges(&self, _user: &User) -> Result<UserPrivilegeSet, Self::Error> {
         Ok(UserPrivilegeSet::all())
     }
 }
 
+#[derive(Clone)]
 pub struct RootResourceService<PR: Resource>(PhantomData<PR>);
 
 impl<PR: Resource> Default for RootResourceService<PR> {
@@ -70,7 +65,7 @@ impl<PR: Resource> Default for RootResourceService<PR> {
 }
 
 #[async_trait(?Send)]
-impl<PR: Resource> ResourceService for RootResourceService<PR> {
+impl<PR: Resource + NamedRoute> ResourceService for RootResourceService<PR> {
     type PathComponents = ();
     type MemberType = PR;
     type Resource = RootResource<PR>;

src/app.rs

@@ -27,7 +27,12 @@ pub fn make_app<AS: AddressbookStore + ?Sized, CS: CalendarStore + ?Sized>(
         .wrap(TracingLogger::default())
         .wrap(NormalizePath::trim())
         .service(web::scope("/caldav").configure(|cfg| {
-            rustical_caldav::configure_dav(cfg, auth_provider.clone(), cal_store.clone())
+            rustical_caldav::configure_dav(
+                cfg,
+                auth_provider.clone(),
+                cal_store.clone(),
+                addr_store.clone(),
+            )
         }))
         .service(web::scope("/carddav").configure(|cfg| {
             rustical_carddav::configure_dav(cfg, auth_provider.clone(), addr_store.clone())