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

//! Presence model for Appwrite SDK

use serde::{Deserialize, Serialize};
use std::collections::HashMap;

/// Presence
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(test, derive(Default))]
pub struct Presence {
    /// Presence ID.
    #[serde(rename = "$id")]
    pub id: String,
    /// Presence creation date in ISO 8601 format.
    #[serde(rename = "$createdAt")]
    pub created_at: String,
    /// Presence update date in ISO 8601 format.
    #[serde(rename = "$updatedAt")]
    pub updated_at: String,
    /// Presence permissions. [Learn more about
    /// permissions](https://appwrite.io/docs/permissions).
    #[serde(rename = "$permissions")]
    pub permissions: Vec<String>,
    /// User ID.
    #[serde(rename = "userId")]
    pub user_id: String,
    /// Presence status.
    #[serde(rename = "status")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub status: Option<String>,
    /// Presence source.
    #[serde(rename = "source")]
    pub source: String,
    /// Presence expiry date in ISO 8601 format.
    #[serde(rename = "expiresAt")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub expires_at: Option<String>,

    #[serde(flatten)]
    pub metadata: HashMap<String, serde_json::Value>,
}

impl Presence {
    /// 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 permissions
    pub fn permissions(&self) -> &Vec<String> {
        &self.permissions
    }

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

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

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

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

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

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


    pub fn get<T: serde::de::DeserializeOwned>(&self, key: &str) -> Option<T> {
        self.metadata.get(key)
            .and_then(|v| serde_json::from_value(v.clone()).ok())
    }

    pub fn metadata(&self) -> &HashMap<String, serde_json::Value> {
        &self.metadata
    }
}

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

    #[test]
    fn test_presence_creation() {
        let _model = <Presence as Default>::default();
        let _ = _model.id();
        let _ = _model.created_at();
        let _ = _model.updated_at();
        let _ = _model.permissions();
        let _ = _model.user_id();
        let _ = _model.source();
    }

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

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