appwrite 0.14.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

//! DedicatedDatabaseBranch model for Appwrite SDK

use serde::{Deserialize, Serialize};

/// Branch
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(test, derive(Default))]
pub struct DedicatedDatabaseBranch {
    /// Branch identifier.
    #[serde(rename = "branchId")]
    pub branch_id: String,
    /// Branch name.
    #[serde(rename = "branchName")]
    pub branch_name: String,
    /// Kubernetes namespace where the branch is deployed.
    #[serde(rename = "namespace")]
    pub namespace: String,
    /// Unix timestamp when the branch expires.
    #[serde(rename = "expiresAt")]
    pub expires_at: i64,
    /// Branch hostname for direct connections.
    #[serde(rename = "host")]
    pub host: String,
    /// Branch port. Null until the backing reports one.
    #[serde(rename = "port")]
    pub port: i64,
    /// Advertised catalog the client connects to. MySQL/MariaDB use default;
    /// Postgres uses the routing label.
    #[serde(rename = "database")]
    pub database: String,
    /// Database username. Shared with the parent database.
    #[serde(rename = "username")]
    pub username: String,
    /// Database password. Shared with the parent database.
    #[serde(rename = "password")]
    pub password: String,
    /// Whether SSL is required.
    #[serde(rename = "ssl")]
    pub ssl: bool,
    /// Database engine. Possible values: postgresql, mysql, mongodb.
    #[serde(rename = "engine")]
    pub engine: String,
    /// Full connection string for the branch.
    #[serde(rename = "connectionString")]
    pub connection_string: String,
}

impl DedicatedDatabaseBranch {
    /// Get branch_id
    pub fn branch_id(&self) -> &String {
        &self.branch_id
    }

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

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

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

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

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

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

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

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

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

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

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

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

    #[test]
    fn test_dedicated_database_branch_creation() {
        let _model = <DedicatedDatabaseBranch as Default>::default();
        let _ = _model.branch_id();
        let _ = _model.branch_name();
        let _ = _model.namespace();
        let _ = _model.expires_at();
        let _ = _model.host();
        let _ = _model.port();
        let _ = _model.database();
        let _ = _model.username();
        let _ = _model.password();
        let _ = _model.ssl();
        let _ = _model.engine();
        let _ = _model.connection_string();
    }

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

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