rust-tdlib 0.4.3

TDlib (Telegram Database library) client
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

use crate::errors::Result;
use crate::types::*;
use uuid::Uuid;

/// An identity document
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct IdentityDocument {
    #[doc(hidden)]
    #[serde(rename(serialize = "@extra", deserialize = "@extra"))]
    extra: Option<String>,
    #[serde(rename(serialize = "@client_id", deserialize = "@client_id"))]
    client_id: Option<i32>,
    /// Document number; 1-24 characters

    #[serde(default)]
    number: String,
    /// Document expiry date; may be null if not applicable
    expiry_date: Option<Date>,
    /// Front side of the document
    front_side: DatedFile,
    /// Reverse side of the document; only for driver license and identity card; may be null
    reverse_side: Option<DatedFile>,
    /// Selfie with the document; may be null
    selfie: Option<DatedFile>,
    /// List of files containing a certified English translation of the document

    #[serde(default)]
    translation: Vec<DatedFile>,
}

impl RObject for IdentityDocument {
    #[doc(hidden)]
    fn extra(&self) -> Option<&str> {
        self.extra.as_deref()
    }
    #[doc(hidden)]
    fn client_id(&self) -> Option<i32> {
        self.client_id
    }
}

impl IdentityDocument {
    pub fn from_json<S: AsRef<str>>(json: S) -> Result<Self> {
        Ok(serde_json::from_str(json.as_ref())?)
    }
    pub fn builder() -> IdentityDocumentBuilder {
        let mut inner = IdentityDocument::default();
        inner.extra = Some(Uuid::new_v4().to_string());

        IdentityDocumentBuilder { inner }
    }

    pub fn number(&self) -> &String {
        &self.number
    }

    pub fn expiry_date(&self) -> &Option<Date> {
        &self.expiry_date
    }

    pub fn front_side(&self) -> &DatedFile {
        &self.front_side
    }

    pub fn reverse_side(&self) -> &Option<DatedFile> {
        &self.reverse_side
    }

    pub fn selfie(&self) -> &Option<DatedFile> {
        &self.selfie
    }

    pub fn translation(&self) -> &Vec<DatedFile> {
        &self.translation
    }
}

#[doc(hidden)]
pub struct IdentityDocumentBuilder {
    inner: IdentityDocument,
}

#[deprecated]
pub type RTDIdentityDocumentBuilder = IdentityDocumentBuilder;

impl IdentityDocumentBuilder {
    pub fn build(&self) -> IdentityDocument {
        self.inner.clone()
    }

    pub fn number<T: AsRef<str>>(&mut self, number: T) -> &mut Self {
        self.inner.number = number.as_ref().to_string();
        self
    }

    pub fn expiry_date<T: AsRef<Date>>(&mut self, expiry_date: T) -> &mut Self {
        self.inner.expiry_date = Some(expiry_date.as_ref().clone());
        self
    }

    pub fn front_side<T: AsRef<DatedFile>>(&mut self, front_side: T) -> &mut Self {
        self.inner.front_side = front_side.as_ref().clone();
        self
    }

    pub fn reverse_side<T: AsRef<DatedFile>>(&mut self, reverse_side: T) -> &mut Self {
        self.inner.reverse_side = Some(reverse_side.as_ref().clone());
        self
    }

    pub fn selfie<T: AsRef<DatedFile>>(&mut self, selfie: T) -> &mut Self {
        self.inner.selfie = Some(selfie.as_ref().clone());
        self
    }

    pub fn translation(&mut self, translation: Vec<DatedFile>) -> &mut Self {
        self.inner.translation = translation;
        self
    }
}

impl AsRef<IdentityDocument> for IdentityDocument {
    fn as_ref(&self) -> &IdentityDocument {
        self
    }
}

impl AsRef<IdentityDocument> for IdentityDocumentBuilder {
    fn as_ref(&self) -> &IdentityDocument {
        &self.inner
    }
}