messagebird_async/sms/
datetime.rs

1use serde::de::{self, Deserialize, Deserializer, Unexpected, Visitor};
2use serde::ser::{Serialize, Serializer};
3
4use std::fmt;
5use std::str::FromStr;
6
7use chrono;
8use chrono::offset::{FixedOffset, Local, Offset};
9use std::ops::Deref;
10
11use crate::errors::*;
12
13/// Timestamp
14///
15/// A timestamp with a fixed offset.
16#[derive(Debug, Eq, PartialEq, Hash, Clone)]
17pub struct DateTime(chrono::DateTime<FixedOffset>);
18
19impl Deref for DateTime {
20    type Target = chrono::DateTime<FixedOffset>;
21    fn deref(&self) -> &Self::Target {
22        &self.0
23    }
24}
25
26use std::time;
27impl Default for DateTime {
28    fn default() -> Self {
29        let systime = time::SystemTime::now();
30        let datetime_local = chrono::DateTime::<Local>::from(systime);
31        let tz = chrono::offset::Utc.fix();
32        let datetime_with_tz = datetime_local.with_timezone(&tz);
33        DateTime(datetime_with_tz)
34    }
35}
36
37impl DateTime {
38    pub fn now() -> Self {
39        Self::default()
40    }
41}
42
43impl FromStr for DateTime {
44    type Err = MessageBirdError;
45    fn from_str(s: &str) -> Result<Self, Self::Err> {
46        // workaround for messy messagebird API
47        // see almost_rfc3339 test case
48        let s_plus_recovered: String = s.replace(' ', "+");
49        debug!("fmt datetime {} -> {}", s, s_plus_recovered);
50        let s = s_plus_recovered.as_str();
51        chrono::DateTime::parse_from_rfc3339(s)
52            .or_else(|_err| {
53                chrono::naive::NaiveDateTime::parse_from_str(s, "%Y%m%d%H%M%S")
54                    .and_then(|naive| Ok(chrono::DateTime::from_utc(naive, FixedOffset::west(0))))
55            })
56            .map(|datetime| DateTime(datetime))
57            .map_err(|_e| MessageBirdError::FormatError {
58                chunk: "Unexpected or invalid time format".to_string(),
59            })
60    }
61}
62
63impl Serialize for DateTime {
64    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
65    where
66        S: Serializer,
67    {
68        serializer.serialize_str(self.0.to_rfc3339().as_str())
69    }
70}
71
72struct DateTimeVisitor;
73
74impl<'de> Visitor<'de> for DateTimeVisitor {
75    type Value = DateTime;
76
77    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
78        formatter.write_str("a valid date time formatted str")
79    }
80
81    fn visit_str<E>(self, value: &str) -> Result<Self::Value, E>
82    where
83        E: de::Error,
84    {
85        Self::Value::from_str(value)
86            .map_err(|_e| de::Error::invalid_value(Unexpected::Str(value), &self))
87    }
88}
89
90impl<'de> Deserialize<'de> for DateTime {
91    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
92    where
93        D: Deserializer<'de>,
94    {
95        deserializer.deserialize_str(DateTimeVisitor)
96    }
97}
98
99#[cfg(test)]
100mod test {
101    use super::*;
102    mod rfc3339 {
103        use super::*;
104        static RAW: &str = r#""2016-05-03T14:26:57+00:00""#;
105        deser_roundtrip!(datetime_deser, DateTime, RAW);
106        serde_roundtrip!(datetime_serde, DateTime, DateTime::default());
107    }
108    mod almost_rfc3339 {
109        use super::*;
110        // XXX necessary, since the notification API is messed up and uses an improperly encoded rfc3339 timestamp
111        // XXX which gets rided of it's plus sign
112        static RAW: &str = r#"2016-05-03T14:26:57 00:00"#;
113        #[test]
114        fn deserialize() {
115            let datetime = DateTime::from_str(RAW).expect("Failed to parse funny format");
116            println!("Time parse from {} is {:?}", RAW, datetime);
117        }
118    }
119    mod custom1 {
120        use super::*;
121        static RAW: &str = r#"20160503142657"#;
122        #[test]
123        fn deserialize() {
124            let datetime = DateTime::from_str(RAW).expect("Failed to parse funny format");
125            println!("Time parse from {} is {:?}", RAW, datetime);
126        }
127    }
128}