rust_tdlib/types/
notification_type.rs1use crate::errors::Result;
2use crate::types::*;
3use uuid::Uuid;
4
5use std::fmt::Debug;
6
7pub trait TDNotificationType: Debug + RObject {}
9
10#[derive(Debug, Clone, Deserialize, Serialize, Default)]
12#[serde(tag = "@type")]
13pub enum NotificationType {
14 #[doc(hidden)]
15 #[default]
16 _Default,
17 #[serde(rename = "notificationTypeNewCall")]
19 NewCall(NotificationTypeNewCall),
20 #[serde(rename = "notificationTypeNewMessage")]
22 NewMessage(Box<NotificationTypeNewMessage>),
23 #[serde(rename = "notificationTypeNewPushMessage")]
25 NewPushMessage(Box<NotificationTypeNewPushMessage>),
26 #[serde(rename = "notificationTypeNewSecretChat")]
28 NewSecretChat(NotificationTypeNewSecretChat),
29}
30
31impl RObject for NotificationType {
32 #[doc(hidden)]
33 fn extra(&self) -> Option<&str> {
34 match self {
35 NotificationType::NewCall(t) => t.extra(),
36 NotificationType::NewMessage(t) => t.extra(),
37 NotificationType::NewPushMessage(t) => t.extra(),
38 NotificationType::NewSecretChat(t) => t.extra(),
39
40 _ => None,
41 }
42 }
43 #[doc(hidden)]
44 fn client_id(&self) -> Option<i32> {
45 match self {
46 NotificationType::NewCall(t) => t.client_id(),
47 NotificationType::NewMessage(t) => t.client_id(),
48 NotificationType::NewPushMessage(t) => t.client_id(),
49 NotificationType::NewSecretChat(t) => t.client_id(),
50
51 _ => None,
52 }
53 }
54}
55
56impl NotificationType {
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, NotificationType::_Default)
63 }
64}
65
66impl AsRef<NotificationType> for NotificationType {
67 fn as_ref(&self) -> &NotificationType {
68 self
69 }
70}
71
72#[derive(Debug, Clone, Default, Serialize, Deserialize)]
74pub struct NotificationTypeNewCall {
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 #[serde(default)]
83 call_id: i32,
84}
85
86impl RObject for NotificationTypeNewCall {
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 TDNotificationType for NotificationTypeNewCall {}
98
99impl NotificationTypeNewCall {
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() -> NotificationTypeNewCallBuilder {
104 let mut inner = NotificationTypeNewCall::default();
105 inner.extra = Some(Uuid::new_v4().to_string());
106
107 NotificationTypeNewCallBuilder { inner }
108 }
109
110 pub fn call_id(&self) -> i32 {
111 self.call_id
112 }
113}
114
115#[doc(hidden)]
116pub struct NotificationTypeNewCallBuilder {
117 inner: NotificationTypeNewCall,
118}
119
120#[deprecated]
121pub type RTDNotificationTypeNewCallBuilder = NotificationTypeNewCallBuilder;
122
123impl NotificationTypeNewCallBuilder {
124 pub fn build(&self) -> NotificationTypeNewCall {
125 self.inner.clone()
126 }
127
128 pub fn call_id(&mut self, call_id: i32) -> &mut Self {
129 self.inner.call_id = call_id;
130 self
131 }
132}
133
134impl AsRef<NotificationTypeNewCall> for NotificationTypeNewCall {
135 fn as_ref(&self) -> &NotificationTypeNewCall {
136 self
137 }
138}
139
140impl AsRef<NotificationTypeNewCall> for NotificationTypeNewCallBuilder {
141 fn as_ref(&self) -> &NotificationTypeNewCall {
142 &self.inner
143 }
144}
145
146#[derive(Debug, Clone, Default, Serialize, Deserialize)]
148pub struct NotificationTypeNewMessage {
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 message: Message,
156}
157
158impl RObject for NotificationTypeNewMessage {
159 #[doc(hidden)]
160 fn extra(&self) -> Option<&str> {
161 self.extra.as_deref()
162 }
163 #[doc(hidden)]
164 fn client_id(&self) -> Option<i32> {
165 self.client_id
166 }
167}
168
169impl TDNotificationType for NotificationTypeNewMessage {}
170
171impl NotificationTypeNewMessage {
172 pub fn from_json<S: AsRef<str>>(json: S) -> Result<Self> {
173 Ok(serde_json::from_str(json.as_ref())?)
174 }
175 pub fn builder() -> NotificationTypeNewMessageBuilder {
176 let mut inner = NotificationTypeNewMessage::default();
177 inner.extra = Some(Uuid::new_v4().to_string());
178
179 NotificationTypeNewMessageBuilder { inner }
180 }
181
182 pub fn message(&self) -> &Message {
183 &self.message
184 }
185}
186
187#[doc(hidden)]
188pub struct NotificationTypeNewMessageBuilder {
189 inner: NotificationTypeNewMessage,
190}
191
192#[deprecated]
193pub type RTDNotificationTypeNewMessageBuilder = NotificationTypeNewMessageBuilder;
194
195impl NotificationTypeNewMessageBuilder {
196 pub fn build(&self) -> NotificationTypeNewMessage {
197 self.inner.clone()
198 }
199
200 pub fn message<T: AsRef<Message>>(&mut self, message: T) -> &mut Self {
201 self.inner.message = message.as_ref().clone();
202 self
203 }
204}
205
206impl AsRef<NotificationTypeNewMessage> for NotificationTypeNewMessage {
207 fn as_ref(&self) -> &NotificationTypeNewMessage {
208 self
209 }
210}
211
212impl AsRef<NotificationTypeNewMessage> for NotificationTypeNewMessageBuilder {
213 fn as_ref(&self) -> &NotificationTypeNewMessage {
214 &self.inner
215 }
216}
217
218#[derive(Debug, Clone, Default, Serialize, Deserialize)]
220pub struct NotificationTypeNewPushMessage {
221 #[doc(hidden)]
222 #[serde(rename(serialize = "@extra", deserialize = "@extra"))]
223 extra: Option<String>,
224 #[serde(rename(serialize = "@client_id", deserialize = "@client_id"))]
225 client_id: Option<i32>,
226 #[serde(default)]
229 message_id: i64,
230 #[serde(skip_serializing_if = "MessageSender::_is_default")]
233 sender_id: MessageSender,
234 #[serde(default)]
237 sender_name: String,
238 #[serde(default)]
241 is_outgoing: bool,
242 #[serde(skip_serializing_if = "PushMessageContent::_is_default")]
245 content: PushMessageContent,
246}
247
248impl RObject for NotificationTypeNewPushMessage {
249 #[doc(hidden)]
250 fn extra(&self) -> Option<&str> {
251 self.extra.as_deref()
252 }
253 #[doc(hidden)]
254 fn client_id(&self) -> Option<i32> {
255 self.client_id
256 }
257}
258
259impl TDNotificationType for NotificationTypeNewPushMessage {}
260
261impl NotificationTypeNewPushMessage {
262 pub fn from_json<S: AsRef<str>>(json: S) -> Result<Self> {
263 Ok(serde_json::from_str(json.as_ref())?)
264 }
265 pub fn builder() -> NotificationTypeNewPushMessageBuilder {
266 let mut inner = NotificationTypeNewPushMessage::default();
267 inner.extra = Some(Uuid::new_v4().to_string());
268
269 NotificationTypeNewPushMessageBuilder { inner }
270 }
271
272 pub fn message_id(&self) -> i64 {
273 self.message_id
274 }
275
276 pub fn sender_id(&self) -> &MessageSender {
277 &self.sender_id
278 }
279
280 pub fn sender_name(&self) -> &String {
281 &self.sender_name
282 }
283
284 pub fn is_outgoing(&self) -> bool {
285 self.is_outgoing
286 }
287
288 pub fn content(&self) -> &PushMessageContent {
289 &self.content
290 }
291}
292
293#[doc(hidden)]
294pub struct NotificationTypeNewPushMessageBuilder {
295 inner: NotificationTypeNewPushMessage,
296}
297
298#[deprecated]
299pub type RTDNotificationTypeNewPushMessageBuilder = NotificationTypeNewPushMessageBuilder;
300
301impl NotificationTypeNewPushMessageBuilder {
302 pub fn build(&self) -> NotificationTypeNewPushMessage {
303 self.inner.clone()
304 }
305
306 pub fn message_id(&mut self, message_id: i64) -> &mut Self {
307 self.inner.message_id = message_id;
308 self
309 }
310
311 pub fn sender_id<T: AsRef<MessageSender>>(&mut self, sender_id: T) -> &mut Self {
312 self.inner.sender_id = sender_id.as_ref().clone();
313 self
314 }
315
316 pub fn sender_name<T: AsRef<str>>(&mut self, sender_name: T) -> &mut Self {
317 self.inner.sender_name = sender_name.as_ref().to_string();
318 self
319 }
320
321 pub fn is_outgoing(&mut self, is_outgoing: bool) -> &mut Self {
322 self.inner.is_outgoing = is_outgoing;
323 self
324 }
325
326 pub fn content<T: AsRef<PushMessageContent>>(&mut self, content: T) -> &mut Self {
327 self.inner.content = content.as_ref().clone();
328 self
329 }
330}
331
332impl AsRef<NotificationTypeNewPushMessage> for NotificationTypeNewPushMessage {
333 fn as_ref(&self) -> &NotificationTypeNewPushMessage {
334 self
335 }
336}
337
338impl AsRef<NotificationTypeNewPushMessage> for NotificationTypeNewPushMessageBuilder {
339 fn as_ref(&self) -> &NotificationTypeNewPushMessage {
340 &self.inner
341 }
342}
343
344#[derive(Debug, Clone, Default, Serialize, Deserialize)]
346pub struct NotificationTypeNewSecretChat {
347 #[doc(hidden)]
348 #[serde(rename(serialize = "@extra", deserialize = "@extra"))]
349 extra: Option<String>,
350 #[serde(rename(serialize = "@client_id", deserialize = "@client_id"))]
351 client_id: Option<i32>,
352}
353
354impl RObject for NotificationTypeNewSecretChat {
355 #[doc(hidden)]
356 fn extra(&self) -> Option<&str> {
357 self.extra.as_deref()
358 }
359 #[doc(hidden)]
360 fn client_id(&self) -> Option<i32> {
361 self.client_id
362 }
363}
364
365impl TDNotificationType for NotificationTypeNewSecretChat {}
366
367impl NotificationTypeNewSecretChat {
368 pub fn from_json<S: AsRef<str>>(json: S) -> Result<Self> {
369 Ok(serde_json::from_str(json.as_ref())?)
370 }
371 pub fn builder() -> NotificationTypeNewSecretChatBuilder {
372 let mut inner = NotificationTypeNewSecretChat::default();
373 inner.extra = Some(Uuid::new_v4().to_string());
374
375 NotificationTypeNewSecretChatBuilder { inner }
376 }
377}
378
379#[doc(hidden)]
380pub struct NotificationTypeNewSecretChatBuilder {
381 inner: NotificationTypeNewSecretChat,
382}
383
384#[deprecated]
385pub type RTDNotificationTypeNewSecretChatBuilder = NotificationTypeNewSecretChatBuilder;
386
387impl NotificationTypeNewSecretChatBuilder {
388 pub fn build(&self) -> NotificationTypeNewSecretChat {
389 self.inner.clone()
390 }
391}
392
393impl AsRef<NotificationTypeNewSecretChat> for NotificationTypeNewSecretChat {
394 fn as_ref(&self) -> &NotificationTypeNewSecretChat {
395 self
396 }
397}
398
399impl AsRef<NotificationTypeNewSecretChat> for NotificationTypeNewSecretChatBuilder {
400 fn as_ref(&self) -> &NotificationTypeNewSecretChat {
401 &self.inner
402 }
403}