Skip to main content

telegram_rich/types/
media.rs

1//! Input media objects used by rich message blocks and [`InputRichMessageMedia`](super::InputRichMessageMedia).
2//!
3//! Each struct serializes its own `type` tag. Captions are accepted for
4//! completeness but are ignored by Telegram inside rich messages; use the
5//! block's `caption` field instead. `caption_entities` is intentionally not
6//! modelled.
7
8use serde::{Deserialize, Serialize};
9
10/// A file to send: a `file_id`, an HTTP URL, or `attach://<name>` for a
11/// multipart upload.
12pub type InputFileRef = String;
13
14/// An animation file (GIF or H.264/MPEG-4 AVC video without sound).
15#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
16#[serde(tag = "type", rename = "animation")]
17pub struct InputMediaAnimation {
18    /// File to send.
19    pub media: InputFileRef,
20    /// Optional. Thumbnail.
21    #[serde(default, skip_serializing_if = "Option::is_none")]
22    pub thumbnail: Option<InputFileRef>,
23    /// Optional. Width.
24    #[serde(default, skip_serializing_if = "Option::is_none")]
25    pub width: Option<u32>,
26    /// Optional. Height.
27    #[serde(default, skip_serializing_if = "Option::is_none")]
28    pub height: Option<u32>,
29    /// Optional. Duration in seconds.
30    #[serde(default, skip_serializing_if = "Option::is_none")]
31    pub duration: Option<u32>,
32    /// Optional. Cover with a spoiler animation.
33    #[serde(default, skip_serializing_if = "Option::is_none")]
34    pub has_spoiler: Option<bool>,
35}
36
37/// An audio file to be treated as music.
38#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
39#[serde(tag = "type", rename = "audio")]
40pub struct InputMediaAudio {
41    /// File to send.
42    pub media: InputFileRef,
43    /// Optional. Thumbnail.
44    #[serde(default, skip_serializing_if = "Option::is_none")]
45    pub thumbnail: Option<InputFileRef>,
46    /// Optional. Duration in seconds.
47    #[serde(default, skip_serializing_if = "Option::is_none")]
48    pub duration: Option<u32>,
49    /// Optional. Performer.
50    #[serde(default, skip_serializing_if = "Option::is_none")]
51    pub performer: Option<String>,
52    /// Optional. Title.
53    #[serde(default, skip_serializing_if = "Option::is_none")]
54    pub title: Option<String>,
55}
56
57/// A general file.
58#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
59#[serde(tag = "type", rename = "document")]
60pub struct InputMediaDocument {
61    /// File to send.
62    pub media: InputFileRef,
63    /// Optional. Thumbnail.
64    #[serde(default, skip_serializing_if = "Option::is_none")]
65    pub thumbnail: Option<InputFileRef>,
66    /// Optional. Disable server-side content type detection.
67    #[serde(default, skip_serializing_if = "Option::is_none")]
68    pub disable_content_type_detection: Option<bool>,
69}
70
71/// A photo.
72#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
73#[serde(tag = "type", rename = "photo")]
74pub struct InputMediaPhoto {
75    /// File to send.
76    pub media: InputFileRef,
77    /// Optional. Cover with a spoiler animation.
78    #[serde(default, skip_serializing_if = "Option::is_none")]
79    pub has_spoiler: Option<bool>,
80}
81
82/// A video.
83#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
84#[serde(tag = "type", rename = "video")]
85pub struct InputMediaVideo {
86    /// File to send.
87    pub media: InputFileRef,
88    /// Optional. Thumbnail.
89    #[serde(default, skip_serializing_if = "Option::is_none")]
90    pub thumbnail: Option<InputFileRef>,
91    /// Optional. Cover image.
92    #[serde(default, skip_serializing_if = "Option::is_none")]
93    pub cover: Option<InputFileRef>,
94    /// Optional. Start timestamp.
95    #[serde(default, skip_serializing_if = "Option::is_none")]
96    pub start_timestamp: Option<u32>,
97    /// Optional. Width.
98    #[serde(default, skip_serializing_if = "Option::is_none")]
99    pub width: Option<u32>,
100    /// Optional. Height.
101    #[serde(default, skip_serializing_if = "Option::is_none")]
102    pub height: Option<u32>,
103    /// Optional. Duration in seconds.
104    #[serde(default, skip_serializing_if = "Option::is_none")]
105    pub duration: Option<u32>,
106    /// Optional. Suitable for streaming.
107    #[serde(default, skip_serializing_if = "Option::is_none")]
108    pub supports_streaming: Option<bool>,
109    /// Optional. Cover with a spoiler animation.
110    #[serde(default, skip_serializing_if = "Option::is_none")]
111    pub has_spoiler: Option<bool>,
112}
113
114/// A voice message (Bot API 10.2).
115#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
116#[serde(tag = "type", rename = "voice_note")]
117pub struct InputMediaVoiceNote {
118    /// File to send.
119    pub media: InputFileRef,
120    /// Optional. Duration in seconds.
121    #[serde(default, skip_serializing_if = "Option::is_none")]
122    pub duration: Option<u32>,
123}
124
125/// Any media that can be referenced from a rich message.
126///
127/// Serializes through the inner struct (which emits its own `type` tag) and
128/// deserializes by dispatching on the `type` field.
129#[derive(Debug, Clone, PartialEq, Serialize)]
130#[serde(untagged)]
131pub enum InputMedia {
132    /// Animation.
133    Animation(InputMediaAnimation),
134    /// Audio.
135    Audio(InputMediaAudio),
136    /// Document.
137    Document(InputMediaDocument),
138    /// Photo.
139    Photo(InputMediaPhoto),
140    /// Video.
141    Video(InputMediaVideo),
142    /// Voice note.
143    VoiceNote(InputMediaVoiceNote),
144}
145
146#[derive(Deserialize)]
147#[serde(tag = "type", rename_all = "snake_case")]
148enum InputMediaTagged {
149    Animation(InputMediaAnimation),
150    Audio(InputMediaAudio),
151    Document(InputMediaDocument),
152    Photo(InputMediaPhoto),
153    Video(InputMediaVideo),
154    VoiceNote(InputMediaVoiceNote),
155}
156
157impl<'de> Deserialize<'de> for InputMedia {
158    fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
159        Ok(match InputMediaTagged::deserialize(d)? {
160            InputMediaTagged::Animation(m) => InputMedia::Animation(m),
161            InputMediaTagged::Audio(m) => InputMedia::Audio(m),
162            InputMediaTagged::Document(m) => InputMedia::Document(m),
163            InputMediaTagged::Photo(m) => InputMedia::Photo(m),
164            InputMediaTagged::Video(m) => InputMedia::Video(m),
165            InputMediaTagged::VoiceNote(m) => InputMedia::VoiceNote(m),
166        })
167    }
168}
169
170macro_rules! simple_ctor {
171    ($t:ident) => {
172        impl $t {
173            /// Creates the media from a file reference with all optional fields unset.
174            pub fn new(media: impl Into<InputFileRef>) -> Self {
175                Self {
176                    media: media.into(),
177                    ..Default::default()
178                }
179            }
180        }
181    };
182}
183
184macro_rules! default_impl {
185    ($t:ident { $($f:ident),* }) => {
186        impl Default for $t {
187            fn default() -> Self {
188                Self { media: String::new(), $($f: None),* }
189            }
190        }
191        simple_ctor!($t);
192    };
193}
194
195default_impl!(InputMediaAnimation {
196    thumbnail,
197    width,
198    height,
199    duration,
200    has_spoiler
201});
202default_impl!(InputMediaAudio {
203    thumbnail,
204    duration,
205    performer,
206    title
207});
208default_impl!(InputMediaDocument {
209    thumbnail,
210    disable_content_type_detection
211});
212default_impl!(InputMediaPhoto { has_spoiler });
213default_impl!(InputMediaVideo {
214    thumbnail,
215    cover,
216    start_timestamp,
217    width,
218    height,
219    duration,
220    supports_streaming,
221    has_spoiler
222});
223default_impl!(InputMediaVoiceNote { duration });