rp1 0.3.1

Easily generate a REST-like CRUD API using Rocket and Diesel
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142

use std::convert::TryFrom;
use std::io::Write;
use std::ops::{Deref, DerefMut};
use std::str::FromStr;

use diesel::data_types::PgTimestamp;
use diesel::deserialize::FromSql;
use diesel::pg::Pg;
use diesel::serialize::{Output, ToSql};
use diesel::sql_types;
use rocket::form::{FromFormField, ValueField};
use serde::de::Visitor;
use serde::{Deserialize, Deserializer};
use time;
use time::format_description::well_known::Rfc3339;
use time::macros::datetime;

/// A PrimitiveDateTime from [time] wrapper that can be used in diesel, serde and rocket contexts.
/// See [time::PrimitiveDateTime] for more details on how to use the datetime itself.
///
/// Note that you should prefer an `PrimitiveDateTime` over a [super::OffsetDateTime].
#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, FromSqlRow, AsExpression)]
#[sql_type = "diesel::sql_types::Timestamp"]
#[sql_type = "diesel::sql_types::Timestamptz"]
pub struct PrimitiveDateTime(time::PrimitiveDateTime);

impl Deref for PrimitiveDateTime {
    type Target = time::PrimitiveDateTime;

    fn deref(&self) -> &Self::Target {
        &self.0
    }
}

impl DerefMut for PrimitiveDateTime {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.0
    }
}

impl AsRef<time::PrimitiveDateTime> for PrimitiveDateTime {
    fn as_ref(&self) -> &time::PrimitiveDateTime {
        &self.0
    }
}

impl AsMut<time::PrimitiveDateTime> for PrimitiveDateTime {
    fn as_mut(&mut self) -> &mut time::PrimitiveDateTime {
        &mut self.0
    }
}

impl ToSql<sql_types::Timestamp, Pg> for PrimitiveDateTime {
    fn to_sql<W: Write>(&self, out: &mut Output<W, Pg>) -> diesel::serialize::Result {
        let difference = (self.0 - datetime!(2000-01-01 00:00:00)).whole_microseconds();
        let postgres_diff = PgTimestamp(i64::try_from(difference)?);
        ToSql::<sql_types::Timestamp, Pg>::to_sql(&postgres_diff, out)
    }
}

impl FromSql<sql_types::Timestamp, Pg> for PrimitiveDateTime {
    fn from_sql(bytes: Option<&[u8]>) -> diesel::deserialize::Result<Self> {
        use time::ext::NumericalDuration;
        let pg_timestamp: PgTimestamp = FromSql::<sql_types::Timestamp, Pg>::from_sql(bytes)?;
        let pg_duration = pg_timestamp.0.microseconds();
        Ok(PrimitiveDateTime(
            datetime!(2000-01-01 00:00:00) + pg_duration,
        ))
    }
}

impl<'v> FromFormField<'v> for PrimitiveDateTime {
    fn from_value(field: ValueField<'v>) -> rocket::form::Result<'v, Self> {
        let dt = Self::from_str(field.value)
            .map_err(|e| Box::new(e) as Box<dyn std::error::Error + Send>)?;
        Ok(dt)
    }
}

impl FromStr for PrimitiveDateTime {
    type Err = time::Error;

    fn from_str(s: &str) -> Result<Self, Self::Err> {
        time::PrimitiveDateTime::parse(s, &Rfc3339)
            .map(|p| PrimitiveDateTime(p))
            .map_err(time::Error::from)
    }
}

impl serde::Serialize for PrimitiveDateTime {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: serde::Serializer,
    {
        serializer.serialize_str(&self.0.format(&Rfc3339).unwrap())
    }
}

struct PrimitiveDateTimeVisitor;

impl<'de> Visitor<'de> for PrimitiveDateTimeVisitor {
    type Value = PrimitiveDateTime;

    fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
        formatter.write_str("a datetime in RFC3339 format")
    }

    fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
    where
        E: serde::de::Error,
    {
        PrimitiveDateTime::from_str(v).map_err(|e| E::custom(format!("invalid datetime: {}", e)))
    }

    fn visit_string<E>(self, v: String) -> Result<Self::Value, E>
    where
        E: serde::de::Error,
    {
        PrimitiveDateTime::from_str(&v).map_err(|e| E::custom(format!("invalid datetime: {}", e)))
    }
}

impl<'de> Deserialize<'de> for PrimitiveDateTime {
    fn deserialize<D>(deserializer: D) -> Result<PrimitiveDateTime, D::Error>
    where
        D: Deserializer<'de>,
    {
        deserializer.deserialize_str(PrimitiveDateTimeVisitor)
    }
}

impl From<time::PrimitiveDateTime> for PrimitiveDateTime {
    fn from(d: time::PrimitiveDateTime) -> Self {
        Self(d)
    }
}

impl Into<time::PrimitiveDateTime> for PrimitiveDateTime {
    fn into(self) -> time::PrimitiveDateTime {
        self.0
    }
}