messagebird_async/sms/
datetime.rs1use 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#[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 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 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}