minio-rsc 0.1.6

rust for minio, the api is compliant with the Amazon S3 protocol.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69

use serde::Deserialize;

use crate::errors::XmlError;

/// Describes the versioning state of an Amazon S3 bucket.
/// - request XML of `get_bucket_versioning` API
/// - response XML of `set_bucket_versioning` API.
#[derive(Clone, Debug, Deserialize, PartialEq)]
#[serde(rename_all = "PascalCase")]
pub struct VersioningConfiguration {
    /// Specifies whether MFA delete is enabled in the bucket versioning configuration.
    /// This element is only returned if the bucket has been configured with MFA delete.
    /// If the bucket has never been so configured, this element is not returned.
    ///
    /// Valid Values: Enabled | Disabled
    mfa_delete: Option<String>,

    /// The versioning state of the bucket.
    ///
    /// Valid Values: Enabled | Suspended
    status: Option<String>,
}

impl VersioningConfiguration {
    /// Create a new VersioningConfiguration object with given status.
    pub fn new(status: bool, mfa_delete: Option<bool>) -> Self {
        Self {
            mfa_delete: mfa_delete.map(|m| (if m { "Enabled" } else { "Disabled" }).to_string()),
            status: Some((if status { "Enabled" } else { "Suspended" }).to_string()),
        }
    }

    pub fn is_mfa_delete_enabled(&self) -> bool {
        self.mfa_delete == Some("Enabled".to_string())
    }

    pub fn is_status_enabled(&self) -> bool {
        self.status == Some("Enabled".to_string())
    }

    pub fn set_mfa_delete(&mut self, mfa_delete: bool) {
        self.mfa_delete = Some((if mfa_delete { "Enabled" } else { "Disabled" }).to_string());
    }

    pub fn set_status_enable(&mut self, enable: bool) {
        self.status = Some((if enable { "Enabled" } else { "Suspended" }).to_string());
    }

    pub fn to_xml(&self) -> String {
        let mut result = "<VersioningConfiguration>".to_string();
        if let Some(mfa) = &self.mfa_delete {
            result += &format!("<MfaDelete>{}</MfaDelete>", mfa);
        }
        if let Some(status) = &self.status {
            result += &format!("<Status>{}</Status>", status);
        } else {
            result += "<Status>Suspended</Status>";
        }
        result += "</VersioningConfiguration>";
        return result;
    }
}

impl TryFrom<&str> for VersioningConfiguration {
    type Error = XmlError;
    fn try_from(value: &str) -> Result<Self, Self::Error> {
        quick_xml::de::from_str(value).map_err(|x| x.into())
    }
}