rustical/crates/dav/src/resource/methods/proppatch.rs

use crate::Error;
use crate::privileges::UserPrivilege;
use crate::resource::Resource;
use crate::resource::ResourceService;
use crate::xml::MultistatusElement;
use crate::xml::TagList;
use crate::xml::multistatus::{PropstatElement, PropstatWrapper, ResponseElement};
use axum::extract::{OriginalUri, Path, State};
use http::StatusCode;
use quick_xml::name::Namespace;
use rustical_xml::NamespaceOwned;
use rustical_xml::PropName;
use rustical_xml::Unparsed;
use rustical_xml::XmlDeserialize;
use rustical_xml::XmlDocument;
use rustical_xml::XmlRootTag;
use std::str::FromStr;

#[derive(XmlDeserialize, Clone, Debug)]
#[xml(untagged)]
enum SetPropertyPropWrapper<T: XmlDeserialize> {
    Valid(T),
    Invalid(Unparsed),
}

// We are <prop>
#[derive(XmlDeserialize, Clone, Debug)]
struct SetPropertyPropWrapperWrapper<T: XmlDeserialize>(
    #[xml(ty = "untagged")] SetPropertyPropWrapper<T>,
);

// We are <set>
#[derive(XmlDeserialize, Clone, Debug)]
struct SetPropertyElement<T: XmlDeserialize> {
    #[xml(ns = "crate::namespace::NS_DAV")]
    prop: T,
}

#[derive(XmlDeserialize, Clone, Debug)]
struct TagName(#[xml(ty = "tag_name")] String);

#[derive(XmlDeserialize, Clone, Debug)]
struct PropertyElement(#[xml(ty = "untagged")] TagName);

#[derive(XmlDeserialize, Clone, Debug)]
struct RemovePropertyElement {
    #[xml(ns = "crate::namespace::NS_DAV")]
    prop: PropertyElement,
}

#[derive(XmlDeserialize, Clone, Debug)]
enum Operation<T: XmlDeserialize> {
    #[xml(ns = "crate::namespace::NS_DAV")]
    Set(SetPropertyElement<T>),
    #[xml(ns = "crate::namespace::NS_DAV")]
    Remove(RemovePropertyElement),
}

#[derive(XmlDeserialize, XmlRootTag, Clone, Debug)]
#[xml(root = b"propertyupdate")]
#[xml(ns = "crate::namespace::NS_DAV")]
struct PropertyupdateElement<T: XmlDeserialize>(#[xml(ty = "untagged", flatten)] Vec<Operation<T>>);

pub(crate) async fn axum_route_proppatch<R: ResourceService>(
    Path(path): Path<R::PathComponents>,
    State(resource_service): State<R>,
    principal: R::Principal,
    uri: OriginalUri,
    body: String,
) -> Result<MultistatusElement<String, String>, R::Error> {
    route_proppatch(&path, uri.path(), &body, &principal, &resource_service).await
}

pub(crate) async fn route_proppatch<R: ResourceService>(
    path_components: &R::PathComponents,
    path: &str,
    body: &str,
    principal: &R::Principal,
    resource_service: &R,
) -> Result<MultistatusElement<String, String>, R::Error> {
    let href = path.to_owned();

    // Extract operations
    let PropertyupdateElement::<SetPropertyPropWrapperWrapper<<R::Resource as Resource>::Prop>>(
        operations,
    ) = XmlDocument::parse_str(body).map_err(Error::XmlError)?;

    let mut resource = resource_service
        .get_resource(path_components, false)
        .await?;
    let privileges = resource.get_user_privileges(principal)?;
    if !privileges.has(&UserPrivilege::Write) {
        return Err(Error::Unauthorized.into());
    }

    let mut props_ok = Vec::new();
    let mut props_conflict = Vec::new();
    let mut props_not_found = Vec::new();

    for operation in operations.into_iter() {
        match operation {
            Operation::Set(SetPropertyElement {
                prop: SetPropertyPropWrapperWrapper(property),
            }) => {
                match property {
                    SetPropertyPropWrapper::Valid(prop) => {
                        let propname: <<R::Resource as Resource>::Prop as PropName>::Names =
                            prop.clone().into();
                        let (ns, propname): (Option<Namespace>, &str) = propname.into();
                        match resource.set_prop(prop) {
                            Ok(()) => {
                                props_ok.push((ns.map(NamespaceOwned::from), propname.to_owned()))
                            }
                            Err(Error::PropReadOnly) => props_conflict
                                .push((ns.map(NamespaceOwned::from), propname.to_owned())),
                            Err(err) => return Err(err.into()),
                        };
                    }
                    SetPropertyPropWrapper::Invalid(invalid) => {
                        let propname = invalid.tag_name();

                        if let Some(full_propname) = <R::Resource as Resource>::list_props()
                            .into_iter()
                            .find_map(|(ns, tag)| {
                                if tag == propname.as_str() {
                                    Some((ns.map(NamespaceOwned::from), tag.to_owned()))
                                } else {
                                    None
                                }
                            })
                        {
                            // This happens in following cases:
                            // - read-only properties with #[serde(skip_deserializing)]
                            // - internal properties
                            props_conflict.push(full_propname)
                        } else {
                            props_not_found.push((None, propname));
                        }
                    }
                }
            }
            Operation::Remove(remove_el) => {
                let propname = remove_el.prop.0.0;
                match <<R::Resource as Resource>::Prop as PropName>::Names::from_str(&propname) {
                    Ok(prop) => match resource.remove_prop(&prop) {
                        Ok(()) => props_ok.push((None, propname)),
                        Err(Error::PropReadOnly) => props_conflict.push({
                            let (ns, tag) = prop.into();
                            (ns.map(NamespaceOwned::from), tag.to_owned())
                        }),
                        Err(err) => return Err(err.into()),
                    },
                    // I guess removing a nonexisting property should be successful :)
                    Err(_) => props_ok.push((None, propname)),
                };
            }
        }
    }

    if props_not_found.is_empty() && props_conflict.is_empty() {
        // Only save if no errors occured
        resource_service
            .save_resource(path_components, resource)
            .await?;
    }

    Ok(MultistatusElement {
        responses: vec![ResponseElement {
            href,
            propstat: vec![
                PropstatWrapper::TagList(PropstatElement {
                    prop: TagList::from(props_ok),
                    status: StatusCode::OK,
                }),
                PropstatWrapper::TagList(PropstatElement {
                    prop: TagList::from(props_not_found),
                    status: StatusCode::NOT_FOUND,
                }),
                PropstatWrapper::TagList(PropstatElement {
                    prop: TagList::from(props_conflict),
                    status: StatusCode::CONFLICT,
                }),
            ],
            ..Default::default()
        }],
        ..Default::default()
    })
}