dav: Introduce resource extension for common properties

crates/dav/src/extension.rs

@@ -0,0 +1,133 @@
+use crate::resource::{Resource, ResourceProp, ResourcePropName};
+use actix_web::dev::ResourceMap;
+use derive_more::derive::Deref;
+use rustical_store::auth::User;
+use std::str::FromStr;
+use strum::VariantNames;
+
+pub trait ResourceExtension<R: Resource>: Clone {
+    type PropName: ResourcePropName;
+    type Prop: ResourceProp;
+    type Error: Into<R::Error> + From<crate::Error>;
+
+    fn list_props() -> &'static [&'static str] {
+        Self::PropName::VARIANTS
+    }
+
+    fn get_prop(
+        &self,
+        resource: &R,
+        rmap: &ResourceMap,
+        user: &User,
+        prop: Self::PropName,
+    ) -> Result<Self::Prop, Self::Error>;
+
+    fn remove_prop(&mut self, _prop: &Self::PropName) -> Result<(), Self::Error> {
+        Err(crate::Error::PropReadOnly.into())
+    }
+}
+
+pub struct ResourceExtensionWrapper;
+
+pub trait BoxableExtension<R: Resource> {
+    fn get_prop(
+        &self,
+        resource: &R,
+        rmap: &ResourceMap,
+        user: &User,
+        prop: R::PropName,
+    ) -> Result<Option<R::Prop>, R::Error>;
+
+    fn propfind<'a>(
+        &self,
+        resource: &R,
+        props: Vec<&'a str>,
+        user: &User,
+        rmap: &ResourceMap,
+    ) -> Result<(Vec<&'a str>, Vec<R::Prop>), R::Error>;
+
+    fn list_props(&self) -> &'static [&'static str];
+}
+
+impl<
+        R: Resource,
+        RE: ResourceExtension<
+            R,
+            PropName: Into<R::PropName> + TryFrom<R::PropName>,
+            Prop: Into<R::Prop> + TryFrom<R::Prop>,
+            Error: Into<R::Error>,
+        >,
+    > BoxableExtension<R> for RE
+{
+    fn get_prop(
+        &self,
+        resource: &R,
+        rmap: &ResourceMap,
+        user: &User,
+        prop: <R as Resource>::PropName,
+    ) -> Result<Option<R::Prop>, R::Error> {
+        let prop: RE::PropName = if let Ok(prop) = prop.try_into() {
+            prop
+        } else {
+            return Ok(None);
+        };
+
+        let prop = ResourceExtension::<R>::get_prop(self, resource, rmap, user, prop)
+            .map_err(RE::Error::into)?;
+        Ok(Some(prop.into()))
+    }
+
+    fn propfind<'a>(
+        &self,
+        resource: &R,
+        props: Vec<&'a str>,
+        user: &User,
+        rmap: &ResourceMap,
+    ) -> Result<(Vec<&'a str>, Vec<R::Prop>), R::Error> {
+        let (valid_props, invalid_props): (Vec<Option<RE::PropName>>, Vec<Option<&str>>) = props
+            .into_iter()
+            .map(|prop| {
+                if let Ok(valid_prop) = RE::PropName::from_str(prop) {
+                    (Some(valid_prop), None)
+                } else {
+                    (None, Some(prop))
+                }
+            })
+            .unzip();
+        let valid_props: Vec<RE::PropName> = valid_props.into_iter().flatten().collect();
+        let invalid_props: Vec<&str> = invalid_props.into_iter().flatten().collect();
+
+        let prop_responses = valid_props
+            .into_iter()
+            .map(|prop| self.get_prop(resource, rmap, user, prop))
+            .collect::<Result<Vec<_>, RE::Error>>()
+            .map_err(RE::Error::into)?
+            .into_iter()
+            .map(|prop| prop.into())
+            .collect::<Vec<_>>();
+
+        Ok((invalid_props, prop_responses))
+    }
+
+    fn list_props(&self) -> &'static [&'static str] {
+        Self::list_props()
+    }
+}
+
+#[derive(Deref)]
+pub struct BoxedExtension<R>(Box<dyn BoxableExtension<R>>);
+
+impl<R: Resource> BoxedExtension<R> {
+    pub fn from_ext<
+        RE: ResourceExtension<
+                R,
+                PropName: Into<R::PropName> + TryFrom<R::PropName>,
+                Prop: Into<R::Prop> + TryFrom<R::Prop>,
+            > + 'static,
+    >(
+        ext: RE,
+    ) -> Self {
+        let boxed_ext: Box<dyn BoxableExtension<R>> = Box::new(ext);
+        BoxedExtension(boxed_ext)
+    }
+}

crates/dav/src/extensions/mod.rs

@@ -0,0 +1,77 @@
+use std::marker::PhantomData;
+
+use actix_web::dev::ResourceMap;
+use rustical_store::auth::User;
+use serde::{Deserialize, Serialize};
+use strum::{EnumString, VariantNames};
+
+use crate::{
+    extension::ResourceExtension,
+    privileges::UserPrivilegeSet,
+    resource::{InvalidProperty, Resource},
+    xml::HrefElement,
+};
+
+#[derive(Debug, Clone)]
+pub struct CommonPropertiesExtension<PR: Resource>(PhantomData<PR>);
+
+impl<PR: Resource> Default for CommonPropertiesExtension<PR> {
+    fn default() -> Self {
+        Self(PhantomData)
+    }
+}
+
+#[derive(Deserialize, Serialize, Debug)]
+#[serde(rename_all = "kebab-case")]
+pub enum CommonPropertiesProp {
+    // WebDAV Current Principal Extension (RFC 5397)
+    CurrentUserPrincipal(HrefElement),
+
+    // WebDAV Access Control Protocol (RFC 3477)
+    CurrentUserPrivilegeSet(UserPrivilegeSet),
+
+    #[serde(untagged)]
+    Invalid,
+}
+
+impl InvalidProperty for CommonPropertiesProp {
+    fn invalid_property(&self) -> bool {
+        matches!(self, Self::Invalid)
+    }
+}
+
+#[derive(EnumString, Debug, VariantNames, Clone)]
+#[strum(serialize_all = "kebab-case")]
+pub enum CommonPropertiesPropName {
+    CurrentUserPrincipal,
+    CurrentUserPrivilegeSet,
+}
+
+impl<R: Resource, PR: Resource> ResourceExtension<R> for CommonPropertiesExtension<PR>
+where
+    R::PropName: TryInto<CommonPropertiesPropName>,
+    R::Prop: From<CommonPropertiesProp>,
+{
+    type Prop = CommonPropertiesProp;
+    type PropName = CommonPropertiesPropName;
+    type Error = R::Error;
+
+    fn get_prop(
+        &self,
+        resource: &R,
+        rmap: &ResourceMap,
+        user: &User,
+        prop: Self::PropName,
+    ) -> Result<Self::Prop, Self::Error> {
+        Ok(match prop {
+            CommonPropertiesPropName::CurrentUserPrincipal => {
+                CommonPropertiesProp::CurrentUserPrincipal(
+                    PR::get_url(rmap, &[&user.id]).unwrap().into(),
+                )
+            }
+            CommonPropertiesPropName::CurrentUserPrivilegeSet => {
+                CommonPropertiesProp::CurrentUserPrivilegeSet(resource.get_user_privileges(user)?)
+            }
+        })
+    }
+}

crates/dav/src/lib.rs

@@ -1,5 +1,7 @@
 pub mod depth_header;
 pub mod error;
+pub mod extension;
+pub mod extensions;
 pub mod methods;
 pub mod namespace;
 pub mod privileges;

crates/dav/src/methods/propfind.rs

@@ -1,5 +1,6 @@
 use crate::depth_header::Depth;
 use crate::privileges::UserPrivilege;
+use crate::resource::InvalidProperty;
 use crate::resource::Resource;
 use crate::resource::ResourceService;
 use crate::xml::multistatus::PropstatWrapper;

crates/dav/src/resource.rs

@@ -1,3 +1,4 @@
+use crate::extension::BoxedExtension;
 use crate::methods::{route_delete, route_propfind, route_proppatch};
 use crate::privileges::UserPrivilegeSet;
 use crate::xml::multistatus::{PropTagWrapper, PropstatElement, PropstatWrapper};
@@ -17,13 +18,31 @@ use serde::{Deserialize, Serialize};
 use std::str::FromStr;
 use strum::VariantNames;
 
+pub trait ResourceReadProp: Serialize + fmt::Debug + InvalidProperty {}
+impl<T: Serialize + fmt::Debug + InvalidProperty> ResourceReadProp for T {}
+
+pub trait ResourceProp: ResourceReadProp + for<'de> Deserialize<'de> {}
+impl<T: ResourceReadProp + for<'de> Deserialize<'de>> ResourceProp for T {}
+
+pub trait ResourcePropName: FromStr + VariantNames {}
+impl<T: FromStr + VariantNames> ResourcePropName for T {}
+
 pub trait Resource: Clone {
-    type PropName: FromStr + VariantNames;
-    type Prop: Serialize + for<'de> Deserialize<'de> + fmt::Debug + InvalidProperty;
+    type PropName: ResourcePropName;
+    type Prop: ResourceProp;
     type Error: ResponseError + From<crate::Error>;
 
-    fn list_props() -> &'static [&'static str] {
+    fn list_extensions() -> Vec<BoxedExtension<Self>> {
+        vec![]
+    }
+
+    fn list_props() -> Vec<&'static str> {
         Self::PropName::VARIANTS
+            .iter()
+            .map(|&prop| prop)
+            // Bodge, since VariantNames somehow includes Ext... props despite the strum(disabled) flag
+            .filter(|prop| !prop.starts_with("ext-"))
+            .collect()
     }
 
     fn get_prop(
@@ -74,10 +93,18 @@ pub trait Resource: Clone {
                     Error::BadRequest("propname MUST be the only queried prop".to_owned()).into(),
                 );
             }
-            let props: Vec<String> = Self::list_props()
+            let mut props: Vec<String> = Self::list_props()
                 .iter()
                 .map(|&prop| prop.to_string())
                 .collect();
+            for extension in Self::list_extensions() {
+                let ext_props: Vec<String> = extension
+                    .list_props()
+                    .iter()
+                    .map(|&prop| prop.to_string())
+                    .collect();
+                props.extend(ext_props);
+            }
             return Ok(ResponseElement {
                 href: path.to_owned(),
                 propstat: vec![PropstatWrapper::TagList(PropstatElement {
@@ -95,6 +122,10 @@ pub trait Resource: Clone {
                 );
             }
             props = Self::list_props().into();
+            for extension in Self::list_extensions() {
+                let ext_props: Vec<&str> = extension.list_props().into();
+                props.extend(ext_props);
+            }
         }
 
         let (valid_props, invalid_props): (Vec<Option<Self::PropName>>, Vec<Option<&str>>) = props
@@ -108,13 +139,20 @@ pub trait Resource: Clone {
             })
             .unzip();
         let valid_props: Vec<Self::PropName> = valid_props.into_iter().flatten().collect();
-        let invalid_props: Vec<&str> = invalid_props.into_iter().flatten().collect();
+        let mut invalid_props: Vec<&str> = invalid_props.into_iter().flatten().collect();
 
-        let prop_responses = valid_props
+        let mut prop_responses = valid_props
             .into_iter()
             .map(|prop| self.get_prop(rmap, user, &prop))
             .collect::<Result<Vec<Self::Prop>, Self::Error>>()?;
 
+        for extension in Self::list_extensions() {
+            let (ext_invalid_props, ext_responses) =
+                extension.propfind(self, invalid_props, user, rmap)?;
+            invalid_props = ext_invalid_props;
+            prop_responses.extend(ext_responses);
+        }
+
         let mut propstats = vec![PropstatWrapper::Normal(PropstatElement {
             status: format!("HTTP/1.1 {}", StatusCode::OK),
             prop: PropTagWrapper {