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::report::route_report_calendar;
use super::prop::{SupportedCalendarComponentSet, SupportedCalendarData, SupportedReportSet};
use crate::calendar_object::resource::CalendarObjectResource;
use crate::calendar_object::resource::{CalendarObjectResource, CalendarObjectResourceService};
use crate::{CalDavPrincipalUri, Error};
use actix_web::http::Method;
use actix_web::web;
use actix_web::web::{self, Data};
use async_trait::async_trait;
use chrono::{DateTime, Utc};
use derive_more::derive::{From, Into};
@@ -21,7 +21,6 @@ use rustical_store::auth::User;
use rustical_store::{Calendar, CalendarStore, SubscriptionStore};
use rustical_xml::{EnumUnitVariants, EnumVariants};
use rustical_xml::{XmlDeserialize, XmlSerialize};
use std::marker::PhantomData;
use std::str::FromStr;
use std::sync::Arc;
@@ -311,14 +310,14 @@ impl Resource for CalendarResource {
pub struct CalendarResourceService<C: CalendarStore, S: SubscriptionStore> {
cal_store: Arc<C>,
__phantom_sub: PhantomData<S>,
sub_store: Arc<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 {
cal_store,
__phantom_sub: PhantomData,
sub_store,
}
}
}
@@ -386,13 +385,17 @@ impl<C: CalendarStore, S: SubscriptionStore> ResourceService for CalendarResourc
Ok(())
}
#[inline]
fn actix_additional_routes(res: actix_web::Resource) -> actix_web::Resource {
fn actix_scope(self) -> actix_web::Scope {
let report_method = web::method(Method::from_str("REPORT").unwrap());
let mkcalendar_method = web::method(Method::from_str("MKCALENDAR").unwrap());
res.route(report_method.to(route_report_calendar::<C>))
.route(mkcalendar_method.to(route_mkcalendar::<C>))
.post(route_post::<C, S>)
web::scope("/{calendar_id}")
.app_data(Data::from(self.sub_store.clone()))
.service(CalendarObjectResourceService::new(self.cal_store.clone()).actix_scope())
.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 crate::{CalDavPrincipalUri, Error};
use actix_web::web;
use async_trait::async_trait;
use derive_more::derive::{From, Into};
use rustical_dav::{
@@ -149,8 +150,11 @@ impl<C: CalendarStore> ResourceService for CalendarObjectResourceService<C> {
Ok(())
}
#[inline]
fn actix_additional_routes(res: actix_web::Resource) -> actix_web::Resource {
res.get(get_event::<C>).put(put_event::<C>)
fn actix_scope(self) -> actix_web::Scope {
web::scope("/{object_id}.ics").service(
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 actix_web::web;
use async_trait::async_trait;
use rustical_dav::extensions::{CommonPropertiesExtension, CommonPropertiesProp};
use rustical_dav::privileges::UserPrivilegeSet;
use rustical_dav::resource::{PrincipalUri, Resource, ResourceService};
use rustical_dav::xml::{Resourcetype, ResourcetypeInner};
use rustical_store::CalendarStore;
use rustical_store::auth::User;
use rustical_store::{CalendarStore, SubscriptionStore};
use rustical_xml::{EnumUnitVariants, EnumVariants, XmlDeserialize, XmlSerialize};
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>,
sub_store: Arc<S>,
}
impl<C: CalendarStore> CalendarSetResourceService<C> {
pub fn new(cal_store: Arc<C>) -> Self {
Self { cal_store }
impl<C: CalendarStore, S: SubscriptionStore> CalendarSetResourceService<C, S> {
pub fn new(name: &'static str, cal_store: Arc<C>, sub_store: Arc<S>) -> Self {
Self {
name,
cal_store,
sub_store,
}
}
}
#[async_trait(?Send)]
impl<C: CalendarStore> ResourceService for CalendarSetResourceService<C> {
impl<C: CalendarStore, S: SubscriptionStore> ResourceService for CalendarSetResourceService<C, S> {
type PathComponents = (String,);
type MemberType = CalendarResource;
type Resource = CalendarSetResource;
@@ -107,4 +114,16 @@ impl<C: CalendarStore> ResourceService for CalendarSetResourceService<C> {
})
.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::{Method, StatusCode};
use actix_web::middleware::{ErrorHandlerResponse, ErrorHandlers};
use actix_web::web::{self, Data};
use calendar::resource::CalendarResourceService;
use calendar_object::resource::CalendarObjectResourceService;
use calendar_set::CalendarSetResourceService;
use actix_web::web::Data;
use derive_more::Constructor;
use principal::{PrincipalResource, PrincipalResourceService};
use rustical_dav::resource::{PrincipalUri, ResourceService, ResourceServiceRoute};
use principal::PrincipalResourceService;
use rustical_dav::resource::{PrincipalUri, ResourceService};
use rustical_dav::resources::RootResourceService;
use rustical_store::auth::{AuthenticationMiddleware, AuthenticationProvider, User};
use rustical_store::{AddressbookStore, CalendarStore, ContactBirthdayStore, SubscriptionStore};
@@ -75,71 +72,19 @@ pub fn caldav_service<
) -> impl HttpServiceFactory {
let birthday_store = Arc::new(ContactBirthdayStore::new(addr_store));
web::scope("")
.wrap(AuthenticationMiddleware::new(auth_provider.clone()))
.wrap(options_handler())
.app_data(Data::from(store.clone()))
.app_data(Data::from(birthday_store.clone()))
.app_data(Data::from(subscription_store))
.app_data(Data::new(CalDavPrincipalUri::new(
format!("{prefix}/principal").leak(),
)))
.service(
RootResourceService::<PrincipalResource, User, CalDavPrincipalUri>::default()
.actix_resource(),
)
.service(
web::scope("/principal").service(
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>())
RootResourceService::<_, User, CalDavPrincipalUri>::new(PrincipalResourceService {
auth_provider: auth_provider.clone(),
sub_store: subscription_store.clone(),
birthday_store: birthday_store.clone(),
cal_store: store.clone(),
})
.actix_scope()
.wrap(AuthenticationMiddleware::new(auth_provider.clone()))
.wrap(options_handler())
.app_data(Data::from(store.clone()))
.app_data(Data::from(birthday_store.clone()))
.app_data(Data::new(CalDavPrincipalUri::new(
format!("{prefix}/principal").leak(),
)))
.service(subscription_resource(subscription_store))
}

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 actix_web::web;
use async_trait::async_trait;
use rustical_dav::extensions::{CommonPropertiesExtension, CommonPropertiesProp};
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_store::auth::user::PrincipalType;
use rustical_store::auth::{AuthenticationProvider, User};
use rustical_store::{CalendarStore, SubscriptionStore};
use rustical_xml::{EnumUnitVariants, EnumVariants, XmlDeserialize, XmlSerialize};
use std::sync::Arc;
#[derive(Clone)]
pub struct PrincipalResource {
principal: User,
home_set: &'static [(&'static str, bool)],
home_set: &'static [&'static str],
}
#[derive(XmlDeserialize, XmlSerialize, PartialEq, Clone)]
@@ -72,7 +74,7 @@ impl Resource for PrincipalResource {
.into_iter()
.map(|principal| puri.principal_uri(principal))
.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))
})
})
@@ -117,13 +119,36 @@ impl Resource for PrincipalResource {
}
}
pub struct PrincipalResourceService<AP: AuthenticationProvider> {
pub auth_provider: Arc<AP>,
pub home_set: &'static [(&'static str, bool)],
#[derive(Debug)]
pub struct PrincipalResourceService<
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)]
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 MemberType = CalendarSetResource;
type Resource = PrincipalResource;
@@ -142,7 +167,7 @@ impl<AP: AuthenticationProvider> ResourceService for PrincipalResourceService<AP
.ok_or(crate::Error::NotFound)?;
Ok(PrincipalResource {
principal: user,
home_set: self.home_set,
home_set: &["calendar", "birthdays"],
})
}
@@ -150,18 +175,42 @@ impl<AP: AuthenticationProvider> ResourceService for PrincipalResourceService<AP
&self,
(principal,): &Self::PathComponents,
) -> Result<Vec<(String, Self::MemberType)>, Self::Error> {
Ok(self
.home_set
.iter()
.map(|&(set_name, read_only)| {
(
set_name.to_string(),
CalendarSetResource {
principal: principal.to_owned(),
read_only,
},
Ok(vec![
(
"calendar".to_owned(),
CalendarSetResource {
principal: principal.to_owned(),
read_only: false,
},
),
(
"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(),
)
})
.collect())
.actix_scope(),
)
.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::{
web::{self, Data, Path},
HttpResponse,
web::{self, Data, Path},
};
use rustical_dav::xml::multistatus::PropstatElement;
use rustical_store::SubscriptionStore;
@@ -17,8 +19,9 @@ async fn handle_delete<S: SubscriptionStore>(
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}")
.app_data(Data::from(sub_store))
.name("subscription")
.delete(handle_delete::<S>)
}

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

@@ -1,4 +1,5 @@
use crate::{CardDavPrincipalUri, Error};
use actix_web::web;
use async_trait::async_trait;
use derive_more::derive::{Constructor, From, Into};
use rustical_dav::{
@@ -146,7 +147,11 @@ impl<AS: AddressbookStore> ResourceService for AddressObjectResourceService<AS>
}
#[inline]
fn actix_additional_routes(res: actix_web::Resource) -> actix_web::Resource {
res.get(get_object::<AS>).put(put_object::<AS>)
fn actix_scope(self) -> actix_web::Scope {
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::report::route_report_addressbook;
use super::prop::{SupportedAddressData, SupportedReportSet};
use crate::address_object::resource::AddressObjectResource;
use crate::address_object::resource::{AddressObjectResource, AddressObjectResourceService};
use crate::{CardDavPrincipalUri, Error};
use actix_web::http::Method;
use actix_web::web;
use actix_web::web::{self, Data};
use async_trait::async_trait;
use derive_more::derive::{From, Into};
use rustical_dav::extensions::{
@@ -18,20 +18,19 @@ use rustical_dav_push::{DavPushExtension, DavPushExtensionProp};
use rustical_store::auth::User;
use rustical_store::{Addressbook, AddressbookStore, SubscriptionStore};
use rustical_xml::{EnumUnitVariants, EnumVariants, XmlDeserialize, XmlSerialize};
use std::marker::PhantomData;
use std::str::FromStr;
use std::sync::Arc;
pub struct AddressbookResourceService<AS: AddressbookStore, S: SubscriptionStore> {
addr_store: Arc<AS>,
__phantom_sub: PhantomData<S>,
sub_store: Arc<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 {
addr_store,
__phantom_sub: PhantomData,
sub_store,
}
}
}
@@ -256,11 +255,17 @@ impl<AS: AddressbookStore, S: SubscriptionStore> ResourceService
}
#[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 report_method = web::method(Method::from_str("REPORT").unwrap());
res.route(mkcol_method.to(route_mkcol::<AS>))
.route(report_method.to(route_report_addressbook::<AS>))
.post(route_post::<AS, S>)
web::scope("/{addressbook_id}")
.app_data(Data::from(self.sub_store.clone()))
.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},
},
middleware::{ErrorHandlerResponse, ErrorHandlers},
web::{self, Data},
web::Data,
};
use address_object::resource::AddressObjectResourceService;
use addressbook::resource::AddressbookResourceService;
use derive_more::Constructor;
pub use error::Error;
use principal::{PrincipalResource, PrincipalResourceService};
use principal::PrincipalResourceService;
use rustical_dav::resource::{PrincipalUri, ResourceService};
use rustical_dav::resources::RootResourceService;
use rustical_store::{
@@ -68,38 +66,19 @@ pub fn carddav_service<AP: AuthenticationProvider, A: AddressbookStore, S: Subsc
store: Arc<A>,
subscription_store: Arc<S>,
) -> impl HttpServiceFactory {
web::scope("")
.wrap(AuthenticationMiddleware::new(auth_provider.clone()))
.wrap(options_handler())
.app_data(Data::from(store.clone()))
.app_data(Data::from(subscription_store))
.app_data(Data::new(CardDavPrincipalUri::new(
format!("{prefix}/principal").leak(),
)))
.service(
RootResourceService::<PrincipalResource, User, CardDavPrincipalUri>::default()
.actix_resource(),
)
.service(
web::scope("/principal").service(
web::scope("/{principal}")
.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(),
),
),
),
),
)
RootResourceService::<_, User, CardDavPrincipalUri>::new(
PrincipalResourceService::<_, _, S>::new(
store.clone(),
auth_provider.clone(),
subscription_store.clone(),
),
)
.actix_scope()
.wrap(AuthenticationMiddleware::new(auth_provider.clone()))
.wrap(options_handler())
.app_data(Data::from(store.clone()))
.app_data(Data::new(CardDavPrincipalUri::new(
format!("{prefix}/principal").leak(),
)))
// TODO: Add endpoint to delete subscriptions
}

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 actix_web::web;
use async_trait::async_trait;
use rustical_dav::extensions::{CommonPropertiesExtension, CommonPropertiesProp};
use rustical_dav::privileges::UserPrivilegeSet;
use rustical_dav::resource::{PrincipalUri, Resource, ResourceService};
use rustical_dav::xml::{HrefElement, Resourcetype, ResourcetypeInner};
use rustical_store::AddressbookStore;
use rustical_store::auth::{AuthenticationProvider, User};
use rustical_store::{AddressbookStore, SubscriptionStore};
use rustical_xml::{EnumUnitVariants, EnumVariants, XmlDeserialize, XmlSerialize};
use std::sync::Arc;
pub struct PrincipalResourceService<A: AddressbookStore, AP: AuthenticationProvider> {
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> PrincipalResourceService<A, AP> {
pub fn new(addr_store: Arc<A>, auth_provider: Arc<AP>) -> Self {
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,
}
}
}
@@ -120,8 +141,8 @@ impl Resource for PrincipalResource {
}
#[async_trait(?Send)]
impl<A: AddressbookStore, AP: AuthenticationProvider> ResourceService
for PrincipalResourceService<A, AP>
impl<A: AddressbookStore, AP: AuthenticationProvider, S: SubscriptionStore> ResourceService
for PrincipalResourceService<A, AP, S>
{
type PathComponents = (String,);
type MemberType = AddressbookResource;
@@ -152,4 +173,16 @@ impl<A: AddressbookStore, AP: AuthenticationProvider> ResourceService
.map(|addressbook| (addressbook.id.to_owned(), addressbook.into()))
.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?
let props = match &propfind.prop {
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::{PrincipalUri, Resource};
use crate::Principal;
use actix_web::dev::{AppService, HttpServiceFactory};
use actix_web::web::Data;
use actix_web::{ResponseError, http::Method, web};
use async_trait::async_trait;
@@ -47,30 +46,12 @@ pub trait ResourceService: Sized + 'static {
#[inline]
fn actix_resource(self) -> actix_web::Resource {
Self::actix_additional_routes(
web::resource("")
.app_data(Data::new(self))
.route(
web::method(Method::from_str("PROPFIND").unwrap()).to(route_propfind::<Self>),
)
.route(
web::method(Method::from_str("PROPPATCH").unwrap()).to(route_proppatch::<Self>),
)
.delete(route_delete::<Self>),
)
web::resource("")
.app_data(Data::new(self))
.route(web::method(Method::from_str("PROPFIND").unwrap()).to(route_propfind::<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)
#[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);
}
fn actix_scope(self) -> actix_web::Scope;
}

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

@@ -5,6 +5,7 @@ use crate::extensions::{
use crate::privileges::UserPrivilegeSet;
use crate::resource::{PrincipalUri, Resource, ResourceService};
use crate::xml::{Resourcetype, ResourcetypeInner};
use actix_web::web;
use async_trait::async_trait;
use std::marker::PhantomData;
@@ -44,30 +45,38 @@ impl<PR: Resource, P: Principal> Resource for RootResource<PR, P> {
}
#[derive(Clone)]
pub struct RootResourceService<PR: Resource, P: Principal, PURI: PrincipalUri>(
PhantomData<PR>,
pub struct RootResourceService<PRS: ResourceService + Clone, P: Principal, PURI: PrincipalUri>(
PRS,
PhantomData<P>,
PhantomData<PURI>,
);
impl<PR: Resource, P: Principal, PURI: PrincipalUri> Default for RootResourceService<PR, P, PURI> {
fn default() -> Self {
Self(PhantomData, PhantomData, PhantomData)
impl<PRS: ResourceService + Clone, P: Principal, PURI: PrincipalUri>
RootResourceService<PRS, P, PURI>
{
pub fn new(principal_resource_service: PRS) -> Self {
Self(principal_resource_service, PhantomData, PhantomData)
}
}
#[async_trait(?Send)]
impl<PR: Resource<Principal = P>, P: Principal, PURI: PrincipalUri> ResourceService
for RootResourceService<PR, P, PURI>
impl<PRS: ResourceService<Principal = P> + Clone, P: Principal, PURI: PrincipalUri> ResourceService
for RootResourceService<PRS, P, PURI>
{
type PathComponents = ();
type MemberType = PR;
type Resource = RootResource<PR, P>;
type Error = PR::Error;
type MemberType = PRS::Resource;
type Resource = RootResource<PRS::Resource, P>;
type Error = PRS::Error;
type Principal = P;
type PrincipalUri = PURI;
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())
}
}