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
156
157
158
159
160
161
162
163
164
165
166

//! AttributeRelationship model for Appwrite SDK

use serde::{Deserialize, Serialize};

/// AttributeRelationship
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(test, derive(Default))]
pub struct AttributeRelationship {
    /// Attribute Key.
    #[serde(rename = "key")]
    pub key: String,
    /// Attribute type.
    #[serde(rename = "type")]
    pub r#type: String,
    /// Attribute status. Possible values: `available`, `processing`, `deleting`,
    /// `stuck`, or `failed`
    #[serde(rename = "status")]
    pub status: crate::enums::AttributeStatus,
    /// Error message. Displays error generated on failure of creating or deleting
    /// an attribute.
    #[serde(rename = "error")]
    pub error: String,
    /// Is attribute required?
    #[serde(rename = "required")]
    pub required: bool,
    /// Is attribute an array?
    #[serde(rename = "array")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub array: Option<bool>,
    /// Attribute creation date in ISO 8601 format.
    #[serde(rename = "$createdAt")]
    pub created_at: String,
    /// Attribute update date in ISO 8601 format.
    #[serde(rename = "$updatedAt")]
    pub updated_at: String,
    /// The ID of the related collection.
    #[serde(rename = "relatedCollection")]
    pub related_collection: String,
    /// The type of the relationship.
    #[serde(rename = "relationType")]
    pub relation_type: String,
    /// Is the relationship two-way?
    #[serde(rename = "twoWay")]
    pub two_way: bool,
    /// The key of the two-way relationship.
    #[serde(rename = "twoWayKey")]
    pub two_way_key: String,
    /// How deleting the parent document will propagate to child documents.
    #[serde(rename = "onDelete")]
    pub on_delete: String,
    /// Whether this is the parent or child side of the relationship
    #[serde(rename = "side")]
    pub side: String,
}

impl AttributeRelationship {
    /// Get key
    pub fn key(&self) -> &String {
        &self.key
    }

    /// Get r#type
    pub fn r#type(&self) -> &String {
        &self.r#type
    }

    /// Get status
    pub fn status(&self) -> &crate::enums::AttributeStatus {
        &self.status
    }

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

    /// Get required
    pub fn required(&self) -> &bool {
        &self.required
    }

    /// Set array
    pub fn set_array(mut self, array: bool) -> Self {
        self.array = Some(array);
        self
    }

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

    /// 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 related_collection
    pub fn related_collection(&self) -> &String {
        &self.related_collection
    }

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

    /// Get two_way
    pub fn two_way(&self) -> &bool {
        &self.two_way
    }

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

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

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

}

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

    #[test]
    fn test_attribute_relationship_creation() {
        let _model = <AttributeRelationship as Default>::default();
        let _ = _model.key();
        let _ = _model.r#type();
        let _ = _model.status();
        let _ = _model.error();
        let _ = _model.required();
        let _ = _model.created_at();
        let _ = _model.updated_at();
        let _ = _model.related_collection();
        let _ = _model.relation_type();
        let _ = _model.two_way();
        let _ = _model.two_way_key();
        let _ = _model.on_delete();
        let _ = _model.side();
    }

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

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