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

//! ColumnRelationship model for Appwrite SDK

use serde::{Deserialize, Serialize};

/// ColumnRelationship
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(test, derive(Default))]
pub struct ColumnRelationship {
    /// Column Key.
    #[serde(rename = "key")]
    pub key: String,
    /// Column type.
    #[serde(rename = "type")]
    pub r#type: String,
    /// Column status. Possible values: `available`, `processing`, `deleting`,
    /// `stuck`, or `failed`
    #[serde(rename = "status")]
    pub status: crate::enums::ColumnStatus,
    /// Error message. Displays error generated on failure of creating or deleting
    /// an column.
    #[serde(rename = "error")]
    pub error: String,
    /// Is column required?
    #[serde(rename = "required")]
    pub required: bool,
    /// Is column an array?
    #[serde(rename = "array")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub array: Option<bool>,
    /// Column creation date in ISO 8601 format.
    #[serde(rename = "$createdAt")]
    pub created_at: String,
    /// Column update date in ISO 8601 format.
    #[serde(rename = "$updatedAt")]
    pub updated_at: String,
    /// The ID of the related table.
    #[serde(rename = "relatedTable")]
    pub related_table: 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 ColumnRelationship {
    /// 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::ColumnStatus {
        &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_table
    pub fn related_table(&self) -> &String {
        &self.related_table
    }

    /// 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_column_relationship_creation() {
        let _model = <ColumnRelationship 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_table();
        let _ = _model.relation_type();
        let _ = _model.two_way();
        let _ = _model.two_way_key();
        let _ = _model.on_delete();
        let _ = _model.side();
    }

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

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