nikdoof/rustical
1
1
Fork 0
mirror of https://github.com/lennart-k/rustical.git synced 2025-12-13 22:52:22 +00:00
Code Issues Packages Projects Releases Wiki Activity

Lots of refactoring around routing

Browse Source
This commit is contained in:
Lennart
2025-06-02 19:41:30 +02:00
parent 08c4bd4289
commit b7c24fe2f0
13 changed files with 245 additions and 212 deletions
Download Patch File Download Diff File Expand all files Collapse all files

27
crates/caldav/src/calendar/resource.rs
View File

@@ -2,10 +2,10 @@ use super::methods::mkcalendar::route_mkcalendar;
use super::methods::post::route_post; use super::methods::post::route_post;
use super::methods::report::route_report_calendar; use super::methods::report::route_report_calendar;
use super::prop::{SupportedCalendarComponentSet, SupportedCalendarData, SupportedReportSet}; use super::prop::{SupportedCalendarComponentSet, SupportedCalendarData, SupportedReportSet};
use crate::calendar_object::resource::CalendarObjectResource; use crate::calendar_object::resource::{CalendarObjectResource, CalendarObjectResourceService};
use crate::{CalDavPrincipalUri, Error}; use crate::{CalDavPrincipalUri, Error};
use actix_web::http::Method; use actix_web::http::Method;
use actix_web::web; use actix_web::web::{self, Data};
use async_trait::async_trait; use async_trait::async_trait;
use chrono::{DateTime, Utc}; use chrono::{DateTime, Utc};
use derive_more::derive::{From, Into}; use derive_more::derive::{From, Into};
@@ -21,7 +21,6 @@ use rustical_store::auth::User;
use rustical_store::{Calendar, CalendarStore, SubscriptionStore}; use rustical_store::{Calendar, CalendarStore, SubscriptionStore};
use rustical_xml::{EnumUnitVariants, EnumVariants}; use rustical_xml::{EnumUnitVariants, EnumVariants};
use rustical_xml::{XmlDeserialize, XmlSerialize}; use rustical_xml::{XmlDeserialize, XmlSerialize};
use std::marker::PhantomData;
use std::str::FromStr; use std::str::FromStr;
use std::sync::Arc; use std::sync::Arc;
@@ -311,14 +310,14 @@ impl Resource for CalendarResource {
pub struct CalendarResourceService<C: CalendarStore, S: SubscriptionStore> { pub struct CalendarResourceService<C: CalendarStore, S: SubscriptionStore> {
cal_store: Arc<C>, cal_store: Arc<C>,
__phantom_sub: PhantomData<S>, sub_store: Arc<S>,
} }
impl<C: CalendarStore, S: SubscriptionStore> CalendarResourceService<C, S> { impl<C: CalendarStore, S: SubscriptionStore> CalendarResourceService<C, S> {
pub fn new(cal_store: Arc<C>) -> Self { pub fn new(cal_store: Arc<C>, sub_store: Arc<S>) -> Self {
Self { Self {
cal_store, cal_store,
__phantom_sub: PhantomData, sub_store,
} }
} }
} }
@@ -386,13 +385,17 @@ impl<C: CalendarStore, S: SubscriptionStore> ResourceService for CalendarResourc
Ok(()) Ok(())
} }
#[inline] fn actix_scope(self) -> actix_web::Scope {
fn actix_additional_routes(res: actix_web::Resource) -> actix_web::Resource {
let report_method = web::method(Method::from_str("REPORT").unwrap()); let report_method = web::method(Method::from_str("REPORT").unwrap());
let mkcalendar_method = web::method(Method::from_str("MKCALENDAR").unwrap()); let mkcalendar_method = web::method(Method::from_str("MKCALENDAR").unwrap());
web::scope("/{calendar_id}")
res.route(report_method.to(route_report_calendar::<C>)) .app_data(Data::from(self.sub_store.clone()))
.route(mkcalendar_method.to(route_mkcalendar::<C>)) .service(CalendarObjectResourceService::new(self.cal_store.clone()).actix_scope())
.post(route_post::<C, S>) .service(
self.actix_resource()
.route(report_method.to(route_report_calendar::<C>))
.route(mkcalendar_method.to(route_mkcalendar::<C>))
.post(route_post::<C, S>),
)
} }
} }

10
crates/caldav/src/calendar_object/resource.rs
View File

@@ -1,5 +1,6 @@
use super::methods::{get_event, put_event}; use super::methods::{get_event, put_event};
use crate::{CalDavPrincipalUri, Error}; use crate::{CalDavPrincipalUri, Error};
use actix_web::web;
use async_trait::async_trait; use async_trait::async_trait;
use derive_more::derive::{From, Into}; use derive_more::derive::{From, Into};
use rustical_dav::{ use rustical_dav::{
@@ -149,8 +150,11 @@ impl<C: CalendarStore> ResourceService for CalendarObjectResourceService<C> {
Ok(()) Ok(())
} }
#[inline] fn actix_scope(self) -> actix_web::Scope {
fn actix_additional_routes(res: actix_web::Resource) -> actix_web::Resource { web::scope("/{object_id}.ics").service(
res.get(get_event::<C>).put(put_event::<C>) self.actix_resource()
.get(get_event::<C>)
.put(put_event::<C>),
)
} }
} }

33
crates/caldav/src/calendar_set/mod.rs
View File

@@ -1,12 +1,13 @@
use crate::calendar::resource::CalendarResource; use crate::calendar::resource::{CalendarResource, CalendarResourceService};
use crate::{CalDavPrincipalUri, Error}; use crate::{CalDavPrincipalUri, Error};
use actix_web::web;
use async_trait::async_trait; use async_trait::async_trait;
use rustical_dav::extensions::{CommonPropertiesExtension, CommonPropertiesProp}; use rustical_dav::extensions::{CommonPropertiesExtension, CommonPropertiesProp};
use rustical_dav::privileges::UserPrivilegeSet; use rustical_dav::privileges::UserPrivilegeSet;
use rustical_dav::resource::{PrincipalUri, Resource, ResourceService}; use rustical_dav::resource::{PrincipalUri, Resource, ResourceService};
use rustical_dav::xml::{Resourcetype, ResourcetypeInner}; use rustical_dav::xml::{Resourcetype, ResourcetypeInner};
use rustical_store::CalendarStore;
use rustical_store::auth::User; use rustical_store::auth::User;
use rustical_store::{CalendarStore, SubscriptionStore};
use rustical_xml::{EnumUnitVariants, EnumVariants, XmlDeserialize, XmlSerialize}; use rustical_xml::{EnumUnitVariants, EnumVariants, XmlDeserialize, XmlSerialize};
use std::sync::Arc; use std::sync::Arc;
@@ -60,18 +61,24 @@ impl Resource for CalendarSetResource {
} }
} }
pub struct CalendarSetResourceService<C: CalendarStore> { pub struct CalendarSetResourceService<C: CalendarStore, S: SubscriptionStore> {
name: &'static str,
cal_store: Arc<C>, cal_store: Arc<C>,
sub_store: Arc<S>,
} }
impl<C: CalendarStore> CalendarSetResourceService<C> { impl<C: CalendarStore, S: SubscriptionStore> CalendarSetResourceService<C, S> {
pub fn new(cal_store: Arc<C>) -> Self { pub fn new(name: &'static str, cal_store: Arc<C>, sub_store: Arc<S>) -> Self {
Self { cal_store } Self {
name,
cal_store,
sub_store,
}
} }
} }
#[async_trait(?Send)] #[async_trait(?Send)]
impl<C: CalendarStore> ResourceService for CalendarSetResourceService<C> { impl<C: CalendarStore, S: SubscriptionStore> ResourceService for CalendarSetResourceService<C, S> {
type PathComponents = (String,); type PathComponents = (String,);
type MemberType = CalendarResource; type MemberType = CalendarResource;
type Resource = CalendarSetResource; type Resource = CalendarSetResource;
@@ -107,4 +114,16 @@ impl<C: CalendarStore> ResourceService for CalendarSetResourceService<C> {
}) })
.collect()) .collect())
} }
fn actix_scope(self) -> actix_web::Scope {
web::scope(&format!("/{}", self.name))
.service(
CalendarResourceService::<_, S>::new(
self.cal_store.clone(),
self.sub_store.clone(),
)
.actix_scope(),
)
.service(self.actix_resource())
}
} }

91
crates/caldav/src/lib.rs
View File

@@ -4,13 +4,10 @@ use actix_web::dev::{HttpServiceFactory, ServiceResponse};
use actix_web::http::header::{self, HeaderName, HeaderValue}; use actix_web::http::header::{self, HeaderName, HeaderValue};
use actix_web::http::{Method, StatusCode}; use actix_web::http::{Method, StatusCode};
use actix_web::middleware::{ErrorHandlerResponse, ErrorHandlers}; use actix_web::middleware::{ErrorHandlerResponse, ErrorHandlers};
use actix_web::web::{self, Data}; use actix_web::web::Data;
use calendar::resource::CalendarResourceService;
use calendar_object::resource::CalendarObjectResourceService;
use calendar_set::CalendarSetResourceService;
use derive_more::Constructor; use derive_more::Constructor;
use principal::{PrincipalResource, PrincipalResourceService}; use principal::PrincipalResourceService;
use rustical_dav::resource::{PrincipalUri, ResourceService, ResourceServiceRoute}; use rustical_dav::resource::{PrincipalUri, ResourceService};
use rustical_dav::resources::RootResourceService; use rustical_dav::resources::RootResourceService;
use rustical_store::auth::{AuthenticationMiddleware, AuthenticationProvider, User}; use rustical_store::auth::{AuthenticationMiddleware, AuthenticationProvider, User};
use rustical_store::{AddressbookStore, CalendarStore, ContactBirthdayStore, SubscriptionStore}; use rustical_store::{AddressbookStore, CalendarStore, ContactBirthdayStore, SubscriptionStore};
@@ -75,71 +72,19 @@ pub fn caldav_service<
) -> impl HttpServiceFactory { ) -> impl HttpServiceFactory {
let birthday_store = Arc::new(ContactBirthdayStore::new(addr_store)); let birthday_store = Arc::new(ContactBirthdayStore::new(addr_store));
web::scope("") RootResourceService::<_, User, CalDavPrincipalUri>::new(PrincipalResourceService {
.wrap(AuthenticationMiddleware::new(auth_provider.clone())) auth_provider: auth_provider.clone(),
.wrap(options_handler()) sub_store: subscription_store.clone(),
.app_data(Data::from(store.clone())) birthday_store: birthday_store.clone(),
.app_data(Data::from(birthday_store.clone())) cal_store: store.clone(),
.app_data(Data::from(subscription_store)) })
.app_data(Data::new(CalDavPrincipalUri::new( .actix_scope()
format!("{prefix}/principal").leak(), .wrap(AuthenticationMiddleware::new(auth_provider.clone()))
))) .wrap(options_handler())
.service( .app_data(Data::from(store.clone()))
RootResourceService::<PrincipalResource, User, CalDavPrincipalUri>::default() .app_data(Data::from(birthday_store.clone()))
.actix_resource(), .app_data(Data::new(CalDavPrincipalUri::new(
) format!("{prefix}/principal").leak(),
.service( )))
web::scope("/principal").service( .service(subscription_resource(subscription_store))
web::scope("/{principal}")
.service(
PrincipalResourceService {
auth_provider,
home_set: &[("calendar", false), ("birthdays", true)],
}
.actix_resource(),
)
.service(
web::scope("/calendar")
.service(
CalendarSetResourceService::new(store.clone()).actix_resource(),
)
.service(
web::scope("/{calendar_id}")
.service(ResourceServiceRoute(
CalendarResourceService::<_, S>::new(store.clone()),
))
.service(
web::scope("/{object_id}.ics").service(
CalendarObjectResourceService::new(store.clone())
.actix_resource(),
),
),
),
)
.service(
web::scope("/birthdays")
.service(
CalendarSetResourceService::new(birthday_store.clone())
.actix_resource(),
)
.service(
web::scope("/{calendar_id}")
.service(ResourceServiceRoute(
CalendarResourceService::<_, S>::new(
birthday_store.clone(),
),
))
.service(
web::scope("/{object_id}.ics").service(
CalendarObjectResourceService::new(
birthday_store.clone(),
)
.actix_resource(),
),
),
),
),
),
)
.service(subscription_resource::<S>())
} }

89
crates/caldav/src/principal/mod.rs
View File

@@ -1,5 +1,6 @@
use crate::calendar_set::CalendarSetResource; use crate::calendar_set::{CalendarSetResource, CalendarSetResourceService};
use crate::{CalDavPrincipalUri, Error}; use crate::{CalDavPrincipalUri, Error};
use actix_web::web;
use async_trait::async_trait; use async_trait::async_trait;
use rustical_dav::extensions::{CommonPropertiesExtension, CommonPropertiesProp}; use rustical_dav::extensions::{CommonPropertiesExtension, CommonPropertiesProp};
use rustical_dav::privileges::UserPrivilegeSet; use rustical_dav::privileges::UserPrivilegeSet;
@@ -7,13 +8,14 @@ use rustical_dav::resource::{PrincipalUri, Resource, ResourceService};
use rustical_dav::xml::{HrefElement, Resourcetype, ResourcetypeInner}; use rustical_dav::xml::{HrefElement, Resourcetype, ResourcetypeInner};
use rustical_store::auth::user::PrincipalType; use rustical_store::auth::user::PrincipalType;
use rustical_store::auth::{AuthenticationProvider, User}; use rustical_store::auth::{AuthenticationProvider, User};
use rustical_store::{CalendarStore, SubscriptionStore};
use rustical_xml::{EnumUnitVariants, EnumVariants, XmlDeserialize, XmlSerialize}; use rustical_xml::{EnumUnitVariants, EnumVariants, XmlDeserialize, XmlSerialize};
use std::sync::Arc; use std::sync::Arc;
#[derive(Clone)] #[derive(Clone)]
pub struct PrincipalResource { pub struct PrincipalResource {
principal: User, principal: User,
home_set: &'static [(&'static str, bool)], home_set: &'static [&'static str],
} }
#[derive(XmlDeserialize, XmlSerialize, PartialEq, Clone)] #[derive(XmlDeserialize, XmlSerialize, PartialEq, Clone)]
@@ -72,7 +74,7 @@ impl Resource for PrincipalResource {
.into_iter() .into_iter()
.map(|principal| puri.principal_uri(principal)) .map(|principal| puri.principal_uri(principal))
.flat_map(|principal_url| { .flat_map(|principal_url| {
self.home_set.iter().map(move |&(home_name, _read_only)| { self.home_set.iter().map(move |&home_name| {
HrefElement::new(format!("{}/{}", &principal_url, home_name)) HrefElement::new(format!("{}/{}", &principal_url, home_name))
}) })
}) })
@@ -117,13 +119,36 @@ impl Resource for PrincipalResource {
} }
} }
pub struct PrincipalResourceService<AP: AuthenticationProvider> { #[derive(Debug)]
pub auth_provider: Arc<AP>, pub struct PrincipalResourceService<
pub home_set: &'static [(&'static str, bool)], AP: AuthenticationProvider,
S: SubscriptionStore,
CS: CalendarStore,
BS: CalendarStore,
> {
pub(crate) auth_provider: Arc<AP>,
pub(crate) sub_store: Arc<S>,
pub(crate) cal_store: Arc<CS>,
pub(crate) birthday_store: Arc<BS>,
}
impl<AP: AuthenticationProvider, S: SubscriptionStore, CS: CalendarStore, BS: CalendarStore> Clone
for PrincipalResourceService<AP, S, CS, BS>
{
fn clone(&self) -> Self {
Self {
auth_provider: self.auth_provider.clone(),
sub_store: self.sub_store.clone(),
cal_store: self.cal_store.clone(),
birthday_store: self.birthday_store.clone(),
}
}
} }
#[async_trait(?Send)] #[async_trait(?Send)]
impl<AP: AuthenticationProvider> ResourceService for PrincipalResourceService<AP> { impl<AP: AuthenticationProvider, S: SubscriptionStore, CS: CalendarStore, BS: CalendarStore>
ResourceService for PrincipalResourceService<AP, S, CS, BS>
{
type PathComponents = (String,); type PathComponents = (String,);
type MemberType = CalendarSetResource; type MemberType = CalendarSetResource;
type Resource = PrincipalResource; type Resource = PrincipalResource;
@@ -142,7 +167,7 @@ impl<AP: AuthenticationProvider> ResourceService for PrincipalResourceService<AP
.ok_or(crate::Error::NotFound)?; .ok_or(crate::Error::NotFound)?;
Ok(PrincipalResource { Ok(PrincipalResource {
principal: user, principal: user,
home_set: self.home_set, home_set: &["calendar", "birthdays"],
}) })
} }
@@ -150,18 +175,42 @@ impl<AP: AuthenticationProvider> ResourceService for PrincipalResourceService<AP
&self, &self,
(principal,): &Self::PathComponents, (principal,): &Self::PathComponents,
) -> Result<Vec<(String, Self::MemberType)>, Self::Error> { ) -> Result<Vec<(String, Self::MemberType)>, Self::Error> {
Ok(self Ok(vec![
.home_set (
.iter() "calendar".to_owned(),
.map(|&(set_name, read_only)| { CalendarSetResource {
( principal: principal.to_owned(),
set_name.to_string(), read_only: false,
CalendarSetResource { },
principal: principal.to_owned(), ),
read_only, (
}, "birthdays".to_owned(),
CalendarSetResource {
principal: principal.to_owned(),
read_only: true,
},
),
])
}
fn actix_scope(self) -> actix_web::Scope {
web::scope("/principal/{principal}")
.service(
CalendarSetResourceService::<_, S>::new(
"calendar",
self.cal_store.clone(),
self.sub_store.clone(),
) )
}) .actix_scope(),
.collect()) )
.service(
CalendarSetResourceService::<_, S>::new(
"birthdays",
self.birthday_store.clone(),
self.sub_store.clone(),
)
.actix_scope(),
)
.service(self.actix_resource())
} }
} }

7
crates/caldav/src/subscription.rs
View File

@@ -1,6 +1,8 @@
use std::sync::Arc;
use actix_web::{ use actix_web::{
web::{self, Data, Path},
HttpResponse, HttpResponse,
web::{self, Data, Path},
}; };
use rustical_dav::xml::multistatus::PropstatElement; use rustical_dav::xml::multistatus::PropstatElement;
use rustical_store::SubscriptionStore; use rustical_store::SubscriptionStore;
@@ -17,8 +19,9 @@ async fn handle_delete<S: SubscriptionStore>(
Ok(HttpResponse::NoContent().body("Unregistered")) Ok(HttpResponse::NoContent().body("Unregistered"))
} }
pub fn subscription_resource<S: SubscriptionStore>() -> actix_web::Resource { pub fn subscription_resource<S: SubscriptionStore>(sub_store: Arc<S>) -> actix_web::Resource {
web::resource("/subscription/{id}") web::resource("/subscription/{id}")
.app_data(Data::from(sub_store))
.name("subscription") .name("subscription")
.delete(handle_delete::<S>) .delete(handle_delete::<S>)
} }

9
crates/carddav/src/address_object/resource.rs
View File

@@ -1,4 +1,5 @@
use crate::{CardDavPrincipalUri, Error}; use crate::{CardDavPrincipalUri, Error};
use actix_web::web;
use async_trait::async_trait; use async_trait::async_trait;
use derive_more::derive::{Constructor, From, Into}; use derive_more::derive::{Constructor, From, Into};
use rustical_dav::{ use rustical_dav::{
@@ -146,7 +147,11 @@ impl<AS: AddressbookStore> ResourceService for AddressObjectResourceService<AS>
} }
#[inline] #[inline]
fn actix_additional_routes(res: actix_web::Resource) -> actix_web::Resource { fn actix_scope(self) -> actix_web::Scope {
res.get(get_object::<AS>).put(put_object::<AS>) web::scope("/{object_id}.vcf").service(
self.actix_resource()
.get(get_object::<AS>)
.put(put_object::<AS>),
)
} }
} }

25
crates/carddav/src/addressbook/resource.rs
View File

@@ -2,10 +2,10 @@ use super::methods::mkcol::route_mkcol;
use super::methods::post::route_post; use super::methods::post::route_post;
use super::methods::report::route_report_addressbook; use super::methods::report::route_report_addressbook;
use super::prop::{SupportedAddressData, SupportedReportSet}; use super::prop::{SupportedAddressData, SupportedReportSet};
use crate::address_object::resource::AddressObjectResource; use crate::address_object::resource::{AddressObjectResource, AddressObjectResourceService};
use crate::{CardDavPrincipalUri, Error}; use crate::{CardDavPrincipalUri, Error};
use actix_web::http::Method; use actix_web::http::Method;
use actix_web::web; use actix_web::web::{self, Data};
use async_trait::async_trait; use async_trait::async_trait;
use derive_more::derive::{From, Into}; use derive_more::derive::{From, Into};
use rustical_dav::extensions::{ use rustical_dav::extensions::{
@@ -18,20 +18,19 @@ use rustical_dav_push::{DavPushExtension, DavPushExtensionProp};
use rustical_store::auth::User; use rustical_store::auth::User;
use rustical_store::{Addressbook, AddressbookStore, SubscriptionStore}; use rustical_store::{Addressbook, AddressbookStore, SubscriptionStore};
use rustical_xml::{EnumUnitVariants, EnumVariants, XmlDeserialize, XmlSerialize}; use rustical_xml::{EnumUnitVariants, EnumVariants, XmlDeserialize, XmlSerialize};
use std::marker::PhantomData;
use std::str::FromStr; use std::str::FromStr;
use std::sync::Arc; use std::sync::Arc;
pub struct AddressbookResourceService<AS: AddressbookStore, S: SubscriptionStore> { pub struct AddressbookResourceService<AS: AddressbookStore, S: SubscriptionStore> {
addr_store: Arc<AS>, addr_store: Arc<AS>,
__phantom_sub: PhantomData<S>, sub_store: Arc<S>,
} }
impl<A: AddressbookStore, S: SubscriptionStore> AddressbookResourceService<A, S> { impl<A: AddressbookStore, S: SubscriptionStore> AddressbookResourceService<A, S> {
pub fn new(addr_store: Arc<A>) -> Self { pub fn new(addr_store: Arc<A>, sub_store: Arc<S>) -> Self {
Self { Self {
addr_store, addr_store,
__phantom_sub: PhantomData, sub_store,
} }
} }
} }
@@ -256,11 +255,17 @@ impl<AS: AddressbookStore, S: SubscriptionStore> ResourceService
} }
#[inline] #[inline]
fn actix_additional_routes(res: actix_web::Resource) -> actix_web::Resource { fn actix_scope(self) -> actix_web::Scope {
let mkcol_method = web::method(Method::from_str("MKCOL").unwrap()); let mkcol_method = web::method(Method::from_str("MKCOL").unwrap());
let report_method = web::method(Method::from_str("REPORT").unwrap()); let report_method = web::method(Method::from_str("REPORT").unwrap());
res.route(mkcol_method.to(route_mkcol::<AS>)) web::scope("/{addressbook_id}")
.route(report_method.to(route_report_addressbook::<AS>)) .app_data(Data::from(self.sub_store.clone()))
.post(route_post::<AS, S>) .service(AddressObjectResourceService::<AS>::new(self.addr_store.clone()).actix_scope())
.service(
self.actix_resource()
.route(mkcol_method.to(route_mkcol::<AS>))
.route(report_method.to(route_report_addressbook::<AS>))
.post(route_post::<AS, S>),
)
} }
} }

55
crates/carddav/src/lib.rs
View File

@@ -7,13 +7,11 @@ use actix_web::{
header::{self, HeaderName, HeaderValue}, header::{self, HeaderName, HeaderValue},
}, },
middleware::{ErrorHandlerResponse, ErrorHandlers}, middleware::{ErrorHandlerResponse, ErrorHandlers},
web::{self, Data}, web::Data,
}; };
use address_object::resource::AddressObjectResourceService;
use addressbook::resource::AddressbookResourceService;
use derive_more::Constructor; use derive_more::Constructor;
pub use error::Error; pub use error::Error;
use principal::{PrincipalResource, PrincipalResourceService}; use principal::PrincipalResourceService;
use rustical_dav::resource::{PrincipalUri, ResourceService}; use rustical_dav::resource::{PrincipalUri, ResourceService};
use rustical_dav::resources::RootResourceService; use rustical_dav::resources::RootResourceService;
use rustical_store::{ use rustical_store::{
@@ -68,38 +66,19 @@ pub fn carddav_service<AP: AuthenticationProvider, A: AddressbookStore, S: Subsc
store: Arc<A>, store: Arc<A>,
subscription_store: Arc<S>, subscription_store: Arc<S>,
) -> impl HttpServiceFactory { ) -> impl HttpServiceFactory {
web::scope("") RootResourceService::<_, User, CardDavPrincipalUri>::new(
.wrap(AuthenticationMiddleware::new(auth_provider.clone())) PrincipalResourceService::<_, _, S>::new(
.wrap(options_handler()) store.clone(),
.app_data(Data::from(store.clone())) auth_provider.clone(),
.app_data(Data::from(subscription_store)) subscription_store.clone(),
.app_data(Data::new(CardDavPrincipalUri::new( ),
format!("{prefix}/principal").leak(), )
))) .actix_scope()
.service( .wrap(AuthenticationMiddleware::new(auth_provider.clone()))
RootResourceService::<PrincipalResource, User, CardDavPrincipalUri>::default() .wrap(options_handler())
.actix_resource(), .app_data(Data::from(store.clone()))
) .app_data(Data::new(CardDavPrincipalUri::new(
.service( format!("{prefix}/principal").leak(),
web::scope("/principal").service( )))
web::scope("/{principal}") // TODO: Add endpoint to delete subscriptions
.service(
PrincipalResourceService::new(store.clone(), auth_provider)
.actix_resource(),
)
.service(
web::scope("/{addressbook_id}")
.service(
AddressbookResourceService::<A, S>::new(store.clone())
.actix_resource(),
)
.service(
web::scope("/{object_id}.vcf").service(
AddressObjectResourceService::<A>::new(store.clone())
.actix_resource(),
),
),
),
),
)
} }

47
crates/carddav/src/principal/mod.rs
View File

@@ -1,25 +1,46 @@
use crate::addressbook::resource::AddressbookResource; use crate::addressbook::resource::{AddressbookResource, AddressbookResourceService};
use crate::{CardDavPrincipalUri, Error}; use crate::{CardDavPrincipalUri, Error};
use actix_web::web;
use async_trait::async_trait; use async_trait::async_trait;
use rustical_dav::extensions::{CommonPropertiesExtension, CommonPropertiesProp}; use rustical_dav::extensions::{CommonPropertiesExtension, CommonPropertiesProp};
use rustical_dav::privileges::UserPrivilegeSet; use rustical_dav::privileges::UserPrivilegeSet;
use rustical_dav::resource::{PrincipalUri, Resource, ResourceService}; use rustical_dav::resource::{PrincipalUri, Resource, ResourceService};
use rustical_dav::xml::{HrefElement, Resourcetype, ResourcetypeInner}; use rustical_dav::xml::{HrefElement, Resourcetype, ResourcetypeInner};
use rustical_store::AddressbookStore;
use rustical_store::auth::{AuthenticationProvider, User}; use rustical_store::auth::{AuthenticationProvider, User};
use rustical_store::{AddressbookStore, SubscriptionStore};
use rustical_xml::{EnumUnitVariants, EnumVariants, XmlDeserialize, XmlSerialize}; use rustical_xml::{EnumUnitVariants, EnumVariants, XmlDeserialize, XmlSerialize};
use std::sync::Arc; use std::sync::Arc;
pub struct PrincipalResourceService<A: AddressbookStore, AP: AuthenticationProvider> { pub struct PrincipalResourceService<
A: AddressbookStore,
AP: AuthenticationProvider,
S: SubscriptionStore,
> {
addr_store: Arc<A>, addr_store: Arc<A>,
auth_provider: Arc<AP>, auth_provider: Arc<AP>,
sub_store: Arc<S>,
} }
impl<A: AddressbookStore, AP: AuthenticationProvider> PrincipalResourceService<A, AP> { impl<A: AddressbookStore, AP: AuthenticationProvider, S: SubscriptionStore> Clone
pub fn new(addr_store: Arc<A>, auth_provider: Arc<AP>) -> Self { 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 { Self {
addr_store, addr_store,
auth_provider, auth_provider,
sub_store,
} }
} }
} }
@@ -120,8 +141,8 @@ impl Resource for PrincipalResource {
} }
#[async_trait(?Send)] #[async_trait(?Send)]
impl<A: AddressbookStore, AP: AuthenticationProvider> ResourceService impl<A: AddressbookStore, AP: AuthenticationProvider, S: SubscriptionStore> ResourceService
for PrincipalResourceService<A, AP> for PrincipalResourceService<A, AP, S>
{ {
type PathComponents = (String,); type PathComponents = (String,);
type MemberType = AddressbookResource; type MemberType = AddressbookResource;
@@ -152,4 +173,16 @@ impl<A: AddressbookStore, AP: AuthenticationProvider> ResourceService
.map(|addressbook| (addressbook.id.to_owned(), addressbook.into())) .map(|addressbook| (addressbook.id.to_owned(), addressbook.into()))
.collect()) .collect())
} }
fn actix_scope(self) -> actix_web::Scope {
web::scope("/principal/{principal}")
.service(
AddressbookResourceService::<_, S>::new(
self.addr_store.clone(),
self.sub_store.clone(),
)
.actix_scope(),
)
.service(self.actix_resource())
}
} }

2
crates/dav/src/resource/methods/propfind.rs
View File

@@ -44,8 +44,6 @@ pub(crate) async fn route_propfind<R: ResourceService>(
} }
}; };
dbg!(&propfind);
// TODO: respect namespaces? // TODO: respect namespaces?
let props = match &propfind.prop { let props = match &propfind.prop {
PropfindType::Allprop => vec!["allprop"], PropfindType::Allprop => vec!["allprop"],

31
crates/dav/src/resource/resource_service.rs
View File

@@ -1,7 +1,6 @@
use super::methods::{route_delete, route_propfind, route_proppatch}; use super::methods::{route_delete, route_propfind, route_proppatch};
use super::{PrincipalUri, Resource}; use super::{PrincipalUri, Resource};
use crate::Principal; use crate::Principal;
use actix_web::dev::{AppService, HttpServiceFactory};
use actix_web::web::Data; use actix_web::web::Data;
use actix_web::{ResponseError, http::Method, web}; use actix_web::{ResponseError, http::Method, web};
use async_trait::async_trait; use async_trait::async_trait;
@@ -47,30 +46,12 @@ pub trait ResourceService: Sized + 'static {
#[inline] #[inline]
fn actix_resource(self) -> actix_web::Resource { fn actix_resource(self) -> actix_web::Resource {
Self::actix_additional_routes( web::resource("")
web::resource("") .app_data(Data::new(self))
.app_data(Data::new(self)) .route(web::method(Method::from_str("PROPFIND").unwrap()).to(route_propfind::<Self>))
.route( .route(web::method(Method::from_str("PROPPATCH").unwrap()).to(route_proppatch::<Self>))
web::method(Method::from_str("PROPFIND").unwrap()).to(route_propfind::<Self>), .delete(route_delete::<Self>)
)
.route(
web::method(Method::from_str("PROPPATCH").unwrap()).to(route_proppatch::<Self>),
)
.delete(route_delete::<Self>),
)
} }
/// Hook for other resources to insert their additional methods (i.e. REPORT, MKCALENDAR) fn actix_scope(self) -> actix_web::Scope;
#[inline]
fn actix_additional_routes(res: actix_web::Resource) -> actix_web::Resource {
res
}
}
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);
}
} }

31
crates/dav/src/resources/root.rs
View File

@@ -5,6 +5,7 @@ use crate::extensions::{
use crate::privileges::UserPrivilegeSet; use crate::privileges::UserPrivilegeSet;
use crate::resource::{PrincipalUri, Resource, ResourceService}; use crate::resource::{PrincipalUri, Resource, ResourceService};
use crate::xml::{Resourcetype, ResourcetypeInner}; use crate::xml::{Resourcetype, ResourcetypeInner};
use actix_web::web;
use async_trait::async_trait; use async_trait::async_trait;
use std::marker::PhantomData; use std::marker::PhantomData;
@@ -44,30 +45,38 @@ impl<PR: Resource, P: Principal> Resource for RootResource<PR, P> {
} }
#[derive(Clone)] #[derive(Clone)]
pub struct RootResourceService<PR: Resource, P: Principal, PURI: PrincipalUri>( pub struct RootResourceService<PRS: ResourceService + Clone, P: Principal, PURI: PrincipalUri>(
PhantomData<PR>, PRS,
PhantomData<P>, PhantomData<P>,
PhantomData<PURI>, PhantomData<PURI>,
); );
impl<PR: Resource, P: Principal, PURI: PrincipalUri> Default for RootResourceService<PR, P, PURI> { impl<PRS: ResourceService + Clone, P: Principal, PURI: PrincipalUri>
fn default() -> Self { RootResourceService<PRS, P, PURI>
Self(PhantomData, PhantomData, PhantomData) {
pub fn new(principal_resource_service: PRS) -> Self {
Self(principal_resource_service, PhantomData, PhantomData)
} }
} }
#[async_trait(?Send)] #[async_trait(?Send)]
impl<PR: Resource<Principal = P>, P: Principal, PURI: PrincipalUri> ResourceService impl<PRS: ResourceService<Principal = P> + Clone, P: Principal, PURI: PrincipalUri> ResourceService
for RootResourceService<PR, P, PURI> for RootResourceService<PRS, P, PURI>
{ {
type PathComponents = (); type PathComponents = ();
type MemberType = PR; type MemberType = PRS::Resource;
type Resource = RootResource<PR, P>; type Resource = RootResource<PRS::Resource, P>;
type Error = PR::Error; type Error = PRS::Error;
type Principal = P; type Principal = P;
type PrincipalUri = PURI; type PrincipalUri = PURI;
async fn get_resource(&self, _: &()) -> Result<Self::Resource, Self::Error> { async fn get_resource(&self, _: &()) -> Result<Self::Resource, Self::Error> {
Ok(RootResource::<PR, P>::default()) Ok(RootResource::<PRS::Resource, P>::default())
}
fn actix_scope(self) -> actix_web::Scope {
web::scope("")
.service(self.0.clone().actix_scope())
.service(self.actix_resource())
} }
} }