mime

Cargo.toml

@@ -22,4 +22,5 @@ async-trait = "0.1.22"
 futures = "0.3.1"
 pin-project = "0.4.6"
 serde_with_macros = "1.0.1"
-either = "1.5.3"
+either = "1.5.3"
+mime = "0.3.16"

src/types/animation.rs

@@ -1,6 +1,6 @@
 use serde::{Deserialize, Serialize};
 
-use crate::types::PhotoSize;
+use crate::types::{PhotoSize, MimeWrapper};
 
 /// This object represents an animation file (GIF or H.264/MPEG-4 AVC video
 /// without sound).
@@ -33,7 +33,7 @@ pub struct Animation {
     pub file_name: Option<String>,
 
     /// A MIME type of the file as defined by a sender.
-    pub mime_type: Option<String>,
+    pub mime_type: Option<MimeWrapper>,
 
     /// A size of a file.
     pub file_size: Option<u32>,
@@ -59,7 +59,7 @@ mod tests {
             "file_size":3452
         },
         "file_name":"some",
-        "mime_type":"gif",
+        "mime_type":"video/gif",
         "file_size":6500}"#;
         let expected = Animation {
             file_id: "id".to_string(),
@@ -75,7 +75,7 @@ mod tests {
                 file_size: Some(3452),
             }),
             file_name: Some("some".to_string()),
-            mime_type: Some("gif".to_string()),
+            mime_type: Some(MimeWrapper { mime: "video/gif".parse().unwrap() }),
             file_size: Some(6500),
         };
         let actual = serde_json::from_str::<Animation>(json).unwrap();

src/types/non_telegram_types/mime_wrapper.rs

@@ -0,0 +1,43 @@
+use mime::Mime;
+use serde::{Serialize, Serializer, Deserialize, Deserializer};
+use serde::de::Visitor;
+use serde::export::Formatter;
+use derive_more::From;
+
+#[derive(Clone, Debug, Eq, Hash, PartialEq, From)]
+pub struct MimeWrapper {
+    pub mime: Mime
+}
+
+impl Serialize for MimeWrapper {
+    fn serialize<S>(&self, serializer: S) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error> where
+        S: Serializer {
+        serializer.serialize_str(self.mime.as_ref())
+    }
+}
+
+struct MimeVisitor;
+impl<'a> Visitor<'a> for MimeVisitor {
+    type Value = MimeWrapper;
+
+    fn expecting(&self, formatter: &mut Formatter<'_>) -> Result<(), serde::export::fmt::Error> {
+        formatter.write_str("mime type")
+    }
+
+    fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
+    where
+        E: serde::de::Error
+    {
+        match v.parse::<Mime>() {
+            Ok(mime_type) => Ok(MimeWrapper { mime: mime_type }),
+            Err(e) => Err(E::custom(e))
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for MimeWrapper {
+    fn deserialize<D>(deserializer: D) -> Result<Self, <D as Deserializer<'de>>::Error> where
+        D: Deserializer<'de> {
+        deserializer.deserialize_str(MimeVisitor)
+    }
+}

src/types/non_telegram_types/mod.rs

@@ -1,7 +1,9 @@
 pub use currency::*;
 pub use country_code::*;
 pub use language_code::*;
+pub use mime_wrapper::*;
 
 mod currency;
 mod country_code;
-mod language_code;
+mod language_code;
+mod mime_wrapper;

src/types/update.rs

@@ -62,10 +62,7 @@ pub enum UpdateKind {
 
 #[cfg(test)]
 mod test {
-    use crate::types::{
-        Chat, ChatKind, ForwardKind, MediaKind, Message, MessageKind, Sender,
-        Update, UpdateKind, User,
-    };
+    use crate::types::{Chat, ChatKind, ForwardKind, MediaKind, Message, MessageKind, Sender, Update, UpdateKind, User, LanguageCode};
 
     // TODO: more tests for deserialization
     #[test]
@@ -114,7 +111,7 @@ mod test {
                         first_name: String::from("Waffle"),
                         last_name: None,
                         username: Some(String::from("WaffleLapkin")),
-                        language_code: Some(String::from("en")),
+                        language_code: Some(LanguageCode::EN),
                     }),
                     forward_kind: ForwardKind::Origin {
                         reply_to_message: None,