webdav_request/res/
privilege.rs

1use serde::Deserialize;
2use serde_json::Value;
3
4#[derive(Clone, Default, Debug, Deserialize)]
5pub struct CurrentUserPrivilegeSet {
6    #[serde(rename = "privilege", default)]
7    privileges: Vec<PrivilegeType>,
8}
9
10impl CurrentUserPrivilegeSet {
11    pub fn privilege(self) -> Privilege {
12        Privilege::from(self.privileges)
13    }
14}
15
16#[derive(Debug, Clone, Copy, PartialEq, Eq)]
17pub enum PrivilegeType {
18    Read,
19    Write,
20    ReadAcl,
21    WriteAcl,
22    All,
23    None,
24}
25impl<'de> Deserialize<'de> for PrivilegeType {
26    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
27    where
28        D: serde::Deserializer<'de>,
29    {
30        let value = Value::deserialize(deserializer)?;
31        Ok(match value {
32            Value::Object(map) => {
33                if map.contains_key("read") {
34                    PrivilegeType::Read
35                } else if map.contains_key("write") {
36                    PrivilegeType::Write
37                } else if map.contains_key("read_acl") {
38                    PrivilegeType::ReadAcl
39                } else if map.contains_key("write_acl") {
40                    PrivilegeType::WriteAcl
41                } else if map.contains_key("all") {
42                    PrivilegeType::All
43                } else {
44                    PrivilegeType::None
45                }
46            }
47            _ => PrivilegeType::None,
48        })
49    }
50}
51
52#[derive(Debug, Default, Deserialize, Clone)]
53#[serde(default)]
54pub struct Privilege {
55    read: bool,
56    write: bool,
57    read_acl: bool,
58    write_acl: bool,
59    all: bool,
60}
61
62impl Privilege {
63    pub fn read(&self) -> bool {
64        self.read
65    }
66    pub fn write(&self) -> bool {
67        self.write
68    }
69    pub fn read_acl(&self) -> bool {
70        self.read_acl
71    }
72    pub fn write_acl(&self) -> bool {
73        self.write_acl
74    }
75    pub fn all(&self) -> bool {
76        self.all
77    }
78}
79
80impl From<Vec<PrivilegeType>> for Privilege {
81    fn from(value: Vec<PrivilegeType>) -> Self {
82        Self {
83            read: value.contains(&PrivilegeType::Read),
84            write: value.contains(&PrivilegeType::Write),
85            read_acl: value.contains(&PrivilegeType::ReadAcl),
86            write_acl: value.contains(&PrivilegeType::WriteAcl),
87            all: value.contains(&PrivilegeType::All),
88        }
89    }
90}