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

Add basic framework for PROPPATCH implementation

Browse Source
This commit is contained in:
Lennart
2024-06-20 19:40:01 +02:00
parent ae58a11500
commit f78f3e8194
8 changed files with 372 additions and 129 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -3,11 +3,11 @@ use actix_web::{web::Data, HttpRequest};
use anyhow::anyhow;
use async_trait::async_trait;
use rustical_auth::AuthInfo;
use rustical_dav::resource::{Resource, ResourceService};
use rustical_dav::resource::{InvalidProperty, Resource, ResourceService};
use rustical_dav::xml_snippets::{HrefElement, TextNode};
use rustical_store::calendar::Calendar;
use rustical_store::CalendarStore;
use serde::Serialize;
use serde::{Deserialize, Serialize};
use std::sync::Arc;
use strum::{EnumString, IntoStaticStr, VariantNames};
use tokio::sync::RwLock;
@@ -19,54 +19,54 @@ pub struct CalendarResource<C: CalendarStore + ?Sized> {
pub calendar_id: String,
}
#[derive(Serialize)]
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(rename_all = "kebab-case")]
pub struct SupportedCalendarComponent {
#[serde(rename = "@name")]
pub name: &'static str,
pub name: String,
}
#[derive(Serialize)]
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(rename_all = "kebab-case")]
pub struct SupportedCalendarComponentSet {
#[serde(rename = "C:comp")]
pub comp: Vec<SupportedCalendarComponent>,
}
#[derive(Serialize)]
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(rename_all = "kebab-case")]
pub struct CalendarData {
#[serde(rename = "@content-type")]
content_type: &'static str,
content_type: String,
#[serde(rename = "@version")]
version: &'static str,
version: String,
}
impl Default for CalendarData {
fn default() -> Self {
Self {
content_type: "text/calendar",
version: "2.0",
content_type: "text/calendar".to_owned(),
version: "2.0".to_owned(),
}
}
}
#[derive(Serialize, Default)]
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[serde(rename_all = "kebab-case")]
pub struct SupportedCalendarData {
#[serde(rename = "C:calendar-data")]
#[serde(rename = "C:calendar-data", alias = "calendar-data")]
calendar_data: CalendarData,
}
#[derive(Serialize, Default)]
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[serde(rename_all = "kebab-case")]
pub struct Resourcetype {
#[serde(rename = "C:calendar")]
#[serde(rename = "C:calendar", alias = "calendar")]
calendar: (),
collection: (),
}
#[derive(Serialize)]
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(rename_all = "kebab-case")]
pub enum UserPrivilege {
Read,
@@ -79,7 +79,7 @@ pub enum UserPrivilege {
Unbind,
}
#[derive(Serialize)]
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(rename_all = "kebab-case")]
pub struct UserPrivilegeWrapper {
#[serde(rename = "$value")]
@@ -92,7 +92,7 @@ impl From<UserPrivilege> for UserPrivilegeWrapper {
}
}
#[derive(Serialize)]
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(rename_all = "kebab-case")]
pub struct UserPrivilegeSet {
privilege: Vec<UserPrivilegeWrapper>,
@@ -117,7 +117,7 @@ impl Default for UserPrivilegeSet {
#[derive(EnumString, Debug, VariantNames, IntoStaticStr, Clone)]
#[strum(serialize_all = "kebab-case")]
pub enum CalendarProp {
pub enum CalendarPropName {
Resourcetype,
CurrentUserPrincipal,
Owner,
@@ -132,9 +132,9 @@ pub enum CalendarProp {
MaxResourceSize,
}
#[derive(Serialize)]
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(rename_all = "kebab-case")]
pub enum CalendarPropResponse {
pub enum CalendarProp {
Resourcetype(Resourcetype),
CurrentUserPrincipal(HrefElement),
Owner(HrefElement),
@@ -158,8 +158,17 @@ pub enum CalendarPropResponse {
Getcontenttype(TextNode),
MaxResourceSize(TextNode),
CurrentUserPrivilegeSet(UserPrivilegeSet),
#[serde(other)]
Invalid,
}
impl InvalidProperty for CalendarProp {
fn invalid_property(&self) -> bool {
matches!(self, Self::Invalid)
}
}
#[derive(Clone, Debug)]
pub struct CalendarFile {
pub calendar: Calendar,
pub principal: String,
@@ -167,60 +176,69 @@ pub struct CalendarFile {
}
impl Resource for CalendarFile {
type PropType = CalendarProp;
type PropResponse = CalendarPropResponse;
type PropName = CalendarPropName;
type Prop = CalendarProp;
type Error = Error;
fn get_prop(
&self,
prefix: &str,
prop: Self::PropType,
) -> Result<Self::PropResponse, Self::Error> {
fn get_prop(&self, prefix: &str, prop: Self::PropName) -> Result<Self::Prop, Self::Error> {
match prop {
CalendarProp::Resourcetype => {
Ok(CalendarPropResponse::Resourcetype(Resourcetype::default()))
CalendarPropName::Resourcetype => {
Ok(CalendarProp::Resourcetype(Resourcetype::default()))
}
CalendarProp::CurrentUserPrincipal => Ok(CalendarPropResponse::CurrentUserPrincipal(
CalendarPropName::CurrentUserPrincipal => Ok(CalendarProp::CurrentUserPrincipal(
HrefElement::new(format!("{}/{}/", prefix, self.principal)),
)),
CalendarProp::Owner => Ok(CalendarPropResponse::Owner(HrefElement::new(format!(
CalendarPropName::Owner => Ok(CalendarProp::Owner(HrefElement::new(format!(
"{}/{}/",
prefix, self.principal
)))),
CalendarProp::Displayname => Ok(CalendarPropResponse::Displayname(TextNode(
CalendarPropName::Displayname => Ok(CalendarProp::Displayname(TextNode(
self.calendar.name.clone(),
))),
CalendarProp::CalendarColor => Ok(CalendarPropResponse::CalendarColor(TextNode(
CalendarPropName::CalendarColor => Ok(CalendarProp::CalendarColor(TextNode(
self.calendar.color.clone(),
))),
CalendarProp::CalendarDescription => Ok(CalendarPropResponse::CalendarDescription(
CalendarPropName::CalendarDescription => Ok(CalendarProp::CalendarDescription(
TextNode(self.calendar.description.clone()),
)),
CalendarProp::CalendarOrder => Ok(CalendarPropResponse::CalendarOrder(TextNode(
CalendarPropName::CalendarOrder => Ok(CalendarProp::CalendarOrder(TextNode(
format!("{}", self.calendar.order).into(),
))),
CalendarProp::SupportedCalendarComponentSet => {
Ok(CalendarPropResponse::SupportedCalendarComponentSet(
SupportedCalendarComponentSet {
comp: vec![SupportedCalendarComponent { name: "VEVENT" }],
},
))
}
CalendarProp::SupportedCalendarData => Ok(CalendarPropResponse::SupportedCalendarData(
CalendarPropName::SupportedCalendarComponentSet => Ok(
CalendarProp::SupportedCalendarComponentSet(SupportedCalendarComponentSet {
comp: vec![SupportedCalendarComponent {
name: "VEVENT".to_owned(),
}],
}),
),
CalendarPropName::SupportedCalendarData => Ok(CalendarProp::SupportedCalendarData(
SupportedCalendarData::default(),
)),
CalendarProp::Getcontenttype => Ok(CalendarPropResponse::Getcontenttype(TextNode(
Some("text/calendar;charset=utf-8".to_owned()),
))),
CalendarProp::MaxResourceSize => Ok(CalendarPropResponse::MaxResourceSize(TextNode(
Some("10000000".to_owned()),
))),
CalendarProp::CurrentUserPrivilegeSet => Ok(
CalendarPropResponse::CurrentUserPrivilegeSet(UserPrivilegeSet::default()),
),
CalendarPropName::Getcontenttype => Ok(CalendarProp::Getcontenttype(TextNode(Some(
"text/calendar;charset=utf-8".to_owned(),
)))),
CalendarPropName::MaxResourceSize => Ok(CalendarProp::MaxResourceSize(TextNode(Some(
"10000000".to_owned(),
)))),
CalendarPropName::CurrentUserPrivilegeSet => Ok(CalendarProp::CurrentUserPrivilegeSet(
UserPrivilegeSet::default(),
)),
}
}
fn set_prop(&mut self, prop: Self::Prop) -> Result<(), rustical_dav::Error> {
match prop {
CalendarProp::CalendarColor(color) => {
self.calendar.color = color.0;
}
CalendarProp::Displayname(TextNode(name)) => {
self.calendar.name = name;
}
_ => return Err(rustical_dav::Error::PropReadOnly),
}
Ok(())
}
fn get_path(&self) -> &str {
&self.path
}
@@ -274,4 +292,13 @@ impl<C: CalendarStore + ?Sized> ResourceService for CalendarResource<C> {
cal_store,
})
}
async fn save_file(&self, file: Self::File) -> Result<(), Self::Error> {
self.cal_store
.write()
.await
.update_calendar(self.calendar_id.to_owned(), file.calendar)
.await?;
Ok(())
}
}

45
crates/caldav/src/event/resource.rs
View File

@@ -3,11 +3,11 @@ use actix_web::{web::Data, HttpRequest};
use anyhow::anyhow;
use async_trait::async_trait;
use rustical_auth::AuthInfo;
use rustical_dav::resource::{Resource, ResourceService};
use rustical_dav::resource::{InvalidProperty, Resource, ResourceService};
use rustical_dav::xml_snippets::TextNode;
use rustical_store::event::Event;
use rustical_store::CalendarStore;
use serde::Serialize;
use serde::{Deserialize, Serialize};
use std::sync::Arc;
use strum::{EnumString, IntoStaticStr, VariantNames};
use tokio::sync::RwLock;
@@ -21,52 +21,59 @@ pub struct EventResource<C: CalendarStore + ?Sized> {
#[derive(EnumString, Debug, VariantNames, IntoStaticStr, Clone)]
#[strum(serialize_all = "kebab-case")]
pub enum EventProp {
pub enum EventPropName {
Getetag,
CalendarData,
Getcontenttype,
}
#[derive(Serialize)]
#[derive(Deserialize, Serialize, Debug, Clone, IntoStaticStr)]
#[serde(rename_all = "kebab-case")]
pub enum EventPropResponse {
pub enum EventProp {
Getetag(TextNode),
#[serde(rename = "C:calendar-data")]
CalendarData(TextNode),
Getcontenttype(TextNode),
#[serde(other)]
Invalid,
}
impl InvalidProperty for EventProp {
fn invalid_property(&self) -> bool {
matches!(self, Self::Invalid)
}
}
#[derive(Clone)]
pub struct EventFile {
pub event: Event,
pub path: String,
}
impl Resource for EventFile {
type PropType = EventProp;
type PropResponse = EventPropResponse;
type PropName = EventPropName;
type Prop = EventProp;
type Error = Error;
fn get_path(&self) -> &str {
&self.path
}
fn get_prop(
&self,
_prefix: &str,
prop: Self::PropType,
) -> Result<Self::PropResponse, Self::Error> {
fn get_prop(&self, _prefix: &str, prop: Self::PropName) -> Result<Self::Prop, Self::Error> {
match prop {
EventProp::Getetag => Ok(EventPropResponse::Getetag(TextNode(Some(
self.event.get_etag(),
)))),
EventProp::CalendarData => Ok(EventPropResponse::CalendarData(TextNode(Some(
EventPropName::Getetag => Ok(EventProp::Getetag(TextNode(Some(self.event.get_etag())))),
EventPropName::CalendarData => Ok(EventProp::CalendarData(TextNode(Some(
self.event.get_ics().to_owned(),
)))),
EventProp::Getcontenttype => Ok(EventPropResponse::Getcontenttype(TextNode(Some(
EventPropName::Getcontenttype => Ok(EventProp::Getcontenttype(TextNode(Some(
"text/calendar;charset=utf-8".to_owned(),
)))),
}
}
fn set_prop(&mut self, _prop: Self::Prop) -> Result<(), rustical_dav::Error> {
Err(rustical_dav::Error::PropReadOnly)
}
}
#[async_trait(?Send)]
@@ -116,4 +123,8 @@ impl<C: CalendarStore + ?Sized> ResourceService for EventResource<C> {
path: self.path.to_owned(),
})
}
async fn save_file(&self, _file: Self::File) -> Result<(), Self::Error> {
Err(Error::NotImplemented)
}
}

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

@@ -7,6 +7,7 @@ use principal::PrincipalResource;
use root::RootResource;
use rustical_auth::CheckAuthentication;
use rustical_dav::propfind::{route_propfind, ServicePrefix};
use rustical_dav::proppatch::route_proppatch;
use rustical_store::CalendarStore;
use std::str::FromStr;
use std::sync::Arc;
@@ -35,6 +36,7 @@ pub fn configure_dav<A: CheckAuthentication, C: CalendarStore + ?Sized>(
store: Arc<RwLock<C>>,
) {
let propfind_method = || web::method(Method::from_str("PROPFIND").unwrap());
let proppatch_method = || web::method(Method::from_str("PROPPATCH").unwrap());
let report_method = || web::method(Method::from_str("REPORT").unwrap());
let mkcalendar_method = || web::method(Method::from_str("MKCALENDAR").unwrap());
@@ -50,15 +52,21 @@ pub fn configure_dav<A: CheckAuthentication, C: CalendarStore + ?Sized>(
.guard(guard::Method(Method::OPTIONS))
.to(options_handler),
)
.service(web::resource("").route(propfind_method().to(route_propfind::<A, RootResource>)))
.service(
web::resource("")
.route(propfind_method().to(route_propfind::<A, RootResource>))
.route(proppatch_method().to(route_proppatch::<A, RootResource>)),
)
.service(
web::resource("/{principal}")
.route(propfind_method().to(route_propfind::<A, PrincipalResource<C>>)),
.route(propfind_method().to(route_propfind::<A, PrincipalResource<C>>))
.route(proppatch_method().to(route_proppatch::<A, PrincipalResource<C>>)),
)
.service(
web::resource("/{principal}/{calendar}")
.route(report_method().to(calendar::methods::report::route_report_calendar::<A, C>))
.route(propfind_method().to(route_propfind::<A, CalendarResource<C>>))
.route(proppatch_method().to(route_proppatch::<A, CalendarResource<C>>))
.route(
mkcalendar_method().to(calendar::methods::mkcalendar::route_mkcol_calendar::<A, C>),
)
@@ -70,6 +78,7 @@ pub fn configure_dav<A: CheckAuthentication, C: CalendarStore + ?Sized>(
.service(
web::resource("/{principal}/{calendar}/{event}")
.route(propfind_method().to(route_propfind::<A, EventResource<C>>))
.route(proppatch_method().to(route_proppatch::<A, EventResource<C>>))
.route(web::method(Method::DELETE).to(event::methods::delete_event::<A, C>))
.route(web::method(Method::GET).to(event::methods::get_event::<A, C>))
.route(web::method(Method::PUT).to(event::methods::put_event::<A, C>)),

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

@@ -4,12 +4,12 @@ use actix_web::HttpRequest;
use anyhow::anyhow;
use async_trait::async_trait;
use rustical_auth::AuthInfo;
use rustical_dav::resource::{Resource, ResourceService};
use rustical_dav::resource::{InvalidProperty, Resource, ResourceService};
use rustical_dav::xml_snippets::HrefElement;
use rustical_store::CalendarStore;
use serde::Serialize;
use serde::{Deserialize, Serialize};
use std::sync::Arc;
use strum::{EnumString, IntoStaticStr, VariantNames};
use strum::{AsRefStr, EnumString, VariantNames};
use tokio::sync::RwLock;
use crate::calendar::resource::CalendarFile;
@@ -20,21 +20,22 @@ pub struct PrincipalResource<C: CalendarStore + ?Sized> {
cal_store: Arc<RwLock<C>>,
}
#[derive(Clone)]
pub struct PrincipalFile {
principal: String,
path: String,
}
#[derive(Serialize, Default)]
#[derive(Deserialize, Serialize, Default, Debug)]
#[serde(rename_all = "kebab-case")]
pub struct Resourcetype {
principal: (),
collection: (),
}
#[derive(Serialize)]
#[derive(Deserialize, Serialize, Debug)]
#[serde(rename_all = "kebab-case")]
pub enum PrincipalPropResponse {
pub enum PrincipalProp {
Resourcetype(Resourcetype),
CurrentUserPrincipal(HrefElement),
#[serde(rename = "principal-URL")]
@@ -43,11 +44,19 @@ pub enum PrincipalPropResponse {
CalendarHomeSet(HrefElement),
#[serde(rename = "C:calendar-user-address-set")]
CalendarUserAddressSet(HrefElement),
#[serde(other)]
Invalid,
}
#[derive(EnumString, Debug, VariantNames, IntoStaticStr, Clone)]
impl InvalidProperty for PrincipalProp {
fn invalid_property(&self) -> bool {
matches!(self, Self::Invalid)
}
}
#[derive(EnumString, Debug, VariantNames, AsRefStr, Clone)]
#[strum(serialize_all = "kebab-case")]
pub enum PrincipalProp {
pub enum PrincipalPropName {
Resourcetype,
CurrentUserPrincipal,
#[strum(serialize = "principal-URL")]
@@ -58,36 +67,34 @@ pub enum PrincipalProp {
#[async_trait(?Send)]
impl Resource for PrincipalFile {
type PropType = PrincipalProp;
type PropResponse = PrincipalPropResponse;
type PropName = PrincipalPropName;
type Prop = PrincipalProp;
type Error = Error;
fn get_prop(
&self,
prefix: &str,
prop: Self::PropType,
) -> Result<Self::PropResponse, Self::Error> {
fn get_prop(&self, prefix: &str, prop: Self::PropName) -> Result<Self::Prop, Self::Error> {
match prop {
PrincipalProp::Resourcetype => {
Ok(PrincipalPropResponse::Resourcetype(Resourcetype::default()))
PrincipalPropName::Resourcetype => {
Ok(PrincipalProp::Resourcetype(Resourcetype::default()))
}
PrincipalProp::CurrentUserPrincipal => Ok(PrincipalPropResponse::CurrentUserPrincipal(
PrincipalPropName::CurrentUserPrincipal => Ok(PrincipalProp::CurrentUserPrincipal(
HrefElement::new(format!("{}/{}/", prefix, self.principal)),
)),
PrincipalProp::PrincipalUrl => Ok(PrincipalPropResponse::PrincipalUrl(
PrincipalPropName::PrincipalUrl => Ok(PrincipalProp::PrincipalUrl(HrefElement::new(
format!("{}/{}/", prefix, self.principal),
))),
PrincipalPropName::CalendarHomeSet => Ok(PrincipalProp::CalendarHomeSet(
HrefElement::new(format!("{}/{}/", prefix, self.principal)),
)),
PrincipalProp::CalendarHomeSet => Ok(PrincipalPropResponse::CalendarHomeSet(
PrincipalPropName::CalendarUserAddressSet => Ok(PrincipalProp::CalendarUserAddressSet(
HrefElement::new(format!("{}/{}/", prefix, self.principal)),
)),
PrincipalProp::CalendarUserAddressSet => {
Ok(PrincipalPropResponse::CalendarUserAddressSet(
HrefElement::new(format!("{}/{}/", prefix, self.principal)),
))
}
}
}
fn set_prop(&mut self, _prop: Self::Prop) -> Result<(), rustical_dav::Error> {
Err(rustical_dav::Error::PropReadOnly)
}
fn get_path(&self) -> &str {
&self.path
}
@@ -147,4 +154,8 @@ impl<C: CalendarStore + ?Sized> ResourceService for PrincipalResource<C> {
})
.collect())
}
async fn save_file(&self, _file: Self::File) -> Result<(), Self::Error> {
Err(Error::NotImplemented)
}
}

43
crates/caldav/src/root/mod.rs
View File

@@ -2,9 +2,9 @@ use crate::Error;
use actix_web::HttpRequest;
use async_trait::async_trait;
use rustical_auth::AuthInfo;
use rustical_dav::resource::{Resource, ResourceService};
use rustical_dav::resource::{InvalidProperty, Resource, ResourceService};
use rustical_dav::xml_snippets::HrefElement;
use serde::Serialize;
use serde::{Deserialize, Serialize};
use strum::{EnumString, IntoStaticStr, VariantNames};
pub struct RootResource {
@@ -14,47 +14,56 @@ pub struct RootResource {
#[derive(EnumString, Debug, VariantNames, IntoStaticStr, Clone)]
#[strum(serialize_all = "kebab-case")]
pub enum RootProp {
pub enum RootPropName {
Resourcetype,
CurrentUserPrincipal,
}
#[derive(Serialize, Default)]
#[derive(Deserialize, Serialize, Default, Debug)]
#[serde(rename_all = "kebab-case")]
pub struct Resourcetype {
collection: (),
}
#[derive(Serialize)]
#[derive(Deserialize, Serialize, Debug)]
#[serde(rename_all = "kebab-case")]
pub enum RootPropResponse {
pub enum RootProp {
Resourcetype(Resourcetype),
CurrentUserPrincipal(HrefElement),
#[serde(other)]
Invalid,
}
impl InvalidProperty for RootProp {
fn invalid_property(&self) -> bool {
matches!(self, Self::Invalid)
}
}
#[derive(Clone)]
pub struct RootFile {
pub principal: String,
pub path: String,
}
impl Resource for RootFile {
type PropType = RootProp;
type PropResponse = RootPropResponse;
type PropName = RootPropName;
type Prop = RootProp;
type Error = Error;
fn get_prop(
&self,
prefix: &str,
prop: Self::PropType,
) -> Result<Self::PropResponse, Self::Error> {
fn get_prop(&self, prefix: &str, prop: Self::PropName) -> Result<Self::Prop, Self::Error> {
match prop {
RootProp::Resourcetype => Ok(RootPropResponse::Resourcetype(Resourcetype::default())),
RootProp::CurrentUserPrincipal => Ok(RootPropResponse::CurrentUserPrincipal(
RootPropName::Resourcetype => Ok(RootProp::Resourcetype(Resourcetype::default())),
RootPropName::CurrentUserPrincipal => Ok(RootProp::CurrentUserPrincipal(
HrefElement::new(format!("{}/{}/", prefix, self.principal)),
)),
}
}
fn set_prop(&mut self, _prop: Self::Prop) -> Result<(), rustical_dav::Error> {
Err(rustical_dav::Error::PropReadOnly)
}
fn get_path(&self) -> &str {
&self.path
}
@@ -91,4 +100,8 @@ impl ResourceService for RootResource {
principal: self.principal.to_owned(),
})
}
async fn save_file(&self, _file: Self::File) -> Result<(), Self::Error> {
Err(Error::NotImplemented)
}
}