rust_tdlib/types/
message_file_type.rs

1use crate::errors::Result;
2use crate::types::*;
3use uuid::Uuid;
4
5use std::fmt::Debug;
6
7/// Contains information about a file with messages exported from another app
8pub trait TDMessageFileType: Debug + RObject {}
9
10/// Contains information about a file with messages exported from another app
11#[derive(Debug, Clone, Deserialize, Serialize, Default)]
12#[serde(tag = "@type")]
13pub enum MessageFileType {
14    #[doc(hidden)]
15    #[default]
16    _Default,
17    /// Returns information about a file with messages exported from another app
18    #[serde(rename = "getMessageFileType")]
19    GetMessageFileType(GetMessageFileType),
20    /// The messages was exported from a group chat
21    #[serde(rename = "messageFileTypeGroup")]
22    Group(MessageFileTypeGroup),
23    /// The messages was exported from a private chat
24    #[serde(rename = "messageFileTypePrivate")]
25    Private(MessageFileTypePrivate),
26    /// The messages was exported from a chat of unknown type
27    #[serde(rename = "messageFileTypeUnknown")]
28    Unknown(MessageFileTypeUnknown),
29}
30
31impl RObject for MessageFileType {
32    #[doc(hidden)]
33    fn extra(&self) -> Option<&str> {
34        match self {
35            MessageFileType::GetMessageFileType(t) => t.extra(),
36            MessageFileType::Group(t) => t.extra(),
37            MessageFileType::Private(t) => t.extra(),
38            MessageFileType::Unknown(t) => t.extra(),
39
40            _ => None,
41        }
42    }
43    #[doc(hidden)]
44    fn client_id(&self) -> Option<i32> {
45        match self {
46            MessageFileType::GetMessageFileType(t) => t.client_id(),
47            MessageFileType::Group(t) => t.client_id(),
48            MessageFileType::Private(t) => t.client_id(),
49            MessageFileType::Unknown(t) => t.client_id(),
50
51            _ => None,
52        }
53    }
54}
55
56impl MessageFileType {
57    pub fn from_json<S: AsRef<str>>(json: S) -> Result<Self> {
58        Ok(serde_json::from_str(json.as_ref())?)
59    }
60    #[doc(hidden)]
61    pub fn _is_default(&self) -> bool {
62        matches!(self, MessageFileType::_Default)
63    }
64}
65
66impl AsRef<MessageFileType> for MessageFileType {
67    fn as_ref(&self) -> &MessageFileType {
68        self
69    }
70}
71
72/// The messages was exported from a group chat
73#[derive(Debug, Clone, Default, Serialize, Deserialize)]
74pub struct MessageFileTypeGroup {
75    #[doc(hidden)]
76    #[serde(rename(serialize = "@extra", deserialize = "@extra"))]
77    extra: Option<String>,
78    #[serde(rename(serialize = "@client_id", deserialize = "@client_id"))]
79    client_id: Option<i32>,
80    /// Title of the group chat; may be empty if unrecognized
81
82    #[serde(default)]
83    title: String,
84}
85
86impl RObject for MessageFileTypeGroup {
87    #[doc(hidden)]
88    fn extra(&self) -> Option<&str> {
89        self.extra.as_deref()
90    }
91    #[doc(hidden)]
92    fn client_id(&self) -> Option<i32> {
93        self.client_id
94    }
95}
96
97impl TDMessageFileType for MessageFileTypeGroup {}
98
99impl MessageFileTypeGroup {
100    pub fn from_json<S: AsRef<str>>(json: S) -> Result<Self> {
101        Ok(serde_json::from_str(json.as_ref())?)
102    }
103    pub fn builder() -> MessageFileTypeGroupBuilder {
104        let mut inner = MessageFileTypeGroup::default();
105        inner.extra = Some(Uuid::new_v4().to_string());
106
107        MessageFileTypeGroupBuilder { inner }
108    }
109
110    pub fn title(&self) -> &String {
111        &self.title
112    }
113}
114
115#[doc(hidden)]
116pub struct MessageFileTypeGroupBuilder {
117    inner: MessageFileTypeGroup,
118}
119
120#[deprecated]
121pub type RTDMessageFileTypeGroupBuilder = MessageFileTypeGroupBuilder;
122
123impl MessageFileTypeGroupBuilder {
124    pub fn build(&self) -> MessageFileTypeGroup {
125        self.inner.clone()
126    }
127
128    pub fn title<T: AsRef<str>>(&mut self, title: T) -> &mut Self {
129        self.inner.title = title.as_ref().to_string();
130        self
131    }
132}
133
134impl AsRef<MessageFileTypeGroup> for MessageFileTypeGroup {
135    fn as_ref(&self) -> &MessageFileTypeGroup {
136        self
137    }
138}
139
140impl AsRef<MessageFileTypeGroup> for MessageFileTypeGroupBuilder {
141    fn as_ref(&self) -> &MessageFileTypeGroup {
142        &self.inner
143    }
144}
145
146/// The messages was exported from a private chat
147#[derive(Debug, Clone, Default, Serialize, Deserialize)]
148pub struct MessageFileTypePrivate {
149    #[doc(hidden)]
150    #[serde(rename(serialize = "@extra", deserialize = "@extra"))]
151    extra: Option<String>,
152    #[serde(rename(serialize = "@client_id", deserialize = "@client_id"))]
153    client_id: Option<i32>,
154    /// Name of the other party; may be empty if unrecognized
155
156    #[serde(default)]
157    name: String,
158}
159
160impl RObject for MessageFileTypePrivate {
161    #[doc(hidden)]
162    fn extra(&self) -> Option<&str> {
163        self.extra.as_deref()
164    }
165    #[doc(hidden)]
166    fn client_id(&self) -> Option<i32> {
167        self.client_id
168    }
169}
170
171impl TDMessageFileType for MessageFileTypePrivate {}
172
173impl MessageFileTypePrivate {
174    pub fn from_json<S: AsRef<str>>(json: S) -> Result<Self> {
175        Ok(serde_json::from_str(json.as_ref())?)
176    }
177    pub fn builder() -> MessageFileTypePrivateBuilder {
178        let mut inner = MessageFileTypePrivate::default();
179        inner.extra = Some(Uuid::new_v4().to_string());
180
181        MessageFileTypePrivateBuilder { inner }
182    }
183
184    pub fn name(&self) -> &String {
185        &self.name
186    }
187}
188
189#[doc(hidden)]
190pub struct MessageFileTypePrivateBuilder {
191    inner: MessageFileTypePrivate,
192}
193
194#[deprecated]
195pub type RTDMessageFileTypePrivateBuilder = MessageFileTypePrivateBuilder;
196
197impl MessageFileTypePrivateBuilder {
198    pub fn build(&self) -> MessageFileTypePrivate {
199        self.inner.clone()
200    }
201
202    pub fn name<T: AsRef<str>>(&mut self, name: T) -> &mut Self {
203        self.inner.name = name.as_ref().to_string();
204        self
205    }
206}
207
208impl AsRef<MessageFileTypePrivate> for MessageFileTypePrivate {
209    fn as_ref(&self) -> &MessageFileTypePrivate {
210        self
211    }
212}
213
214impl AsRef<MessageFileTypePrivate> for MessageFileTypePrivateBuilder {
215    fn as_ref(&self) -> &MessageFileTypePrivate {
216        &self.inner
217    }
218}
219
220/// The messages was exported from a chat of unknown type
221#[derive(Debug, Clone, Default, Serialize, Deserialize)]
222pub struct MessageFileTypeUnknown {
223    #[doc(hidden)]
224    #[serde(rename(serialize = "@extra", deserialize = "@extra"))]
225    extra: Option<String>,
226    #[serde(rename(serialize = "@client_id", deserialize = "@client_id"))]
227    client_id: Option<i32>,
228}
229
230impl RObject for MessageFileTypeUnknown {
231    #[doc(hidden)]
232    fn extra(&self) -> Option<&str> {
233        self.extra.as_deref()
234    }
235    #[doc(hidden)]
236    fn client_id(&self) -> Option<i32> {
237        self.client_id
238    }
239}
240
241impl TDMessageFileType for MessageFileTypeUnknown {}
242
243impl MessageFileTypeUnknown {
244    pub fn from_json<S: AsRef<str>>(json: S) -> Result<Self> {
245        Ok(serde_json::from_str(json.as_ref())?)
246    }
247    pub fn builder() -> MessageFileTypeUnknownBuilder {
248        let mut inner = MessageFileTypeUnknown::default();
249        inner.extra = Some(Uuid::new_v4().to_string());
250
251        MessageFileTypeUnknownBuilder { inner }
252    }
253}
254
255#[doc(hidden)]
256pub struct MessageFileTypeUnknownBuilder {
257    inner: MessageFileTypeUnknown,
258}
259
260#[deprecated]
261pub type RTDMessageFileTypeUnknownBuilder = MessageFileTypeUnknownBuilder;
262
263impl MessageFileTypeUnknownBuilder {
264    pub fn build(&self) -> MessageFileTypeUnknown {
265        self.inner.clone()
266    }
267}
268
269impl AsRef<MessageFileTypeUnknown> for MessageFileTypeUnknown {
270    fn as_ref(&self) -> &MessageFileTypeUnknown {
271        self
272    }
273}
274
275impl AsRef<MessageFileTypeUnknown> for MessageFileTypeUnknownBuilder {
276    fn as_ref(&self) -> &MessageFileTypeUnknown {
277        &self.inner
278    }
279}
rust_tdlib/types/message_file_type.rs

rust_tdlib/types/
message_file_type.rs
