appwrite 0.3.0

Appwrite SDK for Rust
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
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155

//! BackupArchive model for Appwrite SDK

use serde::{Deserialize, Serialize};

/// Archive
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(test, derive(Default))]
pub struct BackupArchive {
    /// Archive ID.
    #[serde(rename = "$id")]
    pub id: String,
    /// Archive creation time in ISO 8601 format.
    #[serde(rename = "$createdAt")]
    pub created_at: String,
    /// Archive update date in ISO 8601 format.
    #[serde(rename = "$updatedAt")]
    pub updated_at: String,
    /// Archive policy ID.
    #[serde(rename = "policyId")]
    pub policy_id: String,
    /// Archive size in bytes.
    #[serde(rename = "size")]
    pub size: i64,
    /// The status of the archive creation. Possible values: pending, processing,
    /// uploading, completed, failed.
    #[serde(rename = "status")]
    pub status: String,
    /// The backup start time.
    #[serde(rename = "startedAt")]
    pub started_at: String,
    /// Migration ID.
    #[serde(rename = "migrationId")]
    pub migration_id: String,
    /// The services that are backed up by this archive.
    #[serde(rename = "services")]
    pub services: Vec<String>,
    /// The resources that are backed up by this archive.
    #[serde(rename = "resources")]
    pub resources: Vec<String>,
    /// The resource ID to backup. Set only if this archive should backup a single
    /// resource.
    #[serde(rename = "resourceId")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub resource_id: Option<String>,
    /// The resource type to backup. Set only if this archive should backup a
    /// single resource.
    #[serde(rename = "resourceType")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub resource_type: Option<String>,
}

impl BackupArchive {
    /// Get id
    pub fn id(&self) -> &String {
        &self.id
    }

    /// Get created_at
    pub fn created_at(&self) -> &String {
        &self.created_at
    }

    /// Get updated_at
    pub fn updated_at(&self) -> &String {
        &self.updated_at
    }

    /// Get policy_id
    pub fn policy_id(&self) -> &String {
        &self.policy_id
    }

    /// Get size
    pub fn size(&self) -> &i64 {
        &self.size
    }

    /// Get status
    pub fn status(&self) -> &String {
        &self.status
    }

    /// Get started_at
    pub fn started_at(&self) -> &String {
        &self.started_at
    }

    /// Get migration_id
    pub fn migration_id(&self) -> &String {
        &self.migration_id
    }

    /// Get services
    pub fn services(&self) -> &Vec<String> {
        &self.services
    }

    /// Get resources
    pub fn resources(&self) -> &Vec<String> {
        &self.resources
    }

    /// Set resource_id
    pub fn set_resource_id(mut self, resource_id: String) -> Self {
        self.resource_id = Some(resource_id);
        self
    }

    /// Get resource_id
    pub fn resource_id(&self) -> Option<&String> {
        self.resource_id.as_ref()
    }

    /// Set resource_type
    pub fn set_resource_type(mut self, resource_type: String) -> Self {
        self.resource_type = Some(resource_type);
        self
    }

    /// Get resource_type
    pub fn resource_type(&self) -> Option<&String> {
        self.resource_type.as_ref()
    }

}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_backup_archive_creation() {
        let _model = <BackupArchive as Default>::default();
        let _ = _model.id();
        let _ = _model.created_at();
        let _ = _model.updated_at();
        let _ = _model.policy_id();
        let _ = _model.size();
        let _ = _model.status();
        let _ = _model.started_at();
        let _ = _model.migration_id();
        let _ = _model.services();
        let _ = _model.resources();
    }

    #[test]
    fn test_backup_archive_serialization() {
        let model = <BackupArchive as Default>::default();
        let json = serde_json::to_string(&model);
        assert!(json.is_ok());

        let deserialized: Result<BackupArchive, _> = serde_json::from_str(&json.unwrap());
        assert!(deserialized.is_ok());
    }
}