FromForm Support for chrono::DateTime<Utc>?

[WarrenN1]

Is there support in rocket for chrono::DateTime or another datetime format? I need to handle forms that come with date data on it and can't find any imports.

1. Is this something that developers have to implement themselves?
2. If it is, are there any crates/code examples you would recommend I research to do so?

[Mike-Neto]

Rocket already supports date/time formats using time: https://api.rocket.rs/v0.5-rc/rocket/form/trait.FromForm.html#provided-implementations .

#[macro_use]
extern crate rocket;

use rocket::form::Form;
use rocket::time::PrimitiveDateTime;

#[derive(FromForm, Debug)]
struct Task<'r> {
    name: &'r str,
    due: PrimitiveDateTime,
}

#[post("/", data = "<task>")]
fn index(task: Form<Task<'_>>) -> String {
    format!("{task:?}")
}

#[launch]
fn rocket() -> _ {
    rocket::build().mount("/", routes![index])
}

#[cfg(test)]
mod test {
    use super::rocket;
    use rocket::http::{ContentType, Status};
    use rocket::local::blocking::Client;

    #[test]
    fn it_works() {
        let client = Client::tracked(rocket()).expect("valid rocket instance");
        let response = client
            .post(uri!(super::index))
            .header(ContentType::Form)
            .body("name=Run&due=2023-12-25T11:00")
            .dispatch();
        assert_eq!(response.status(), Status::Ok);
        assert_eq!(
            response.into_string().unwrap(),
            "Form(Task { name: \"Run\", due: 2023-12-25 11:00:00.0 })"
        );
    }
}

So you could use this functionality and map from that to chrono DateTime if you still need aditional functionality from the chrono crate.

[Atlinx]

Is there built-in support for PrimitiveDateTime in JSON data guards? I noticed that I kept on getting 422 Unprocessable Entity error when I try using a PrimitiveDateTime in my json type:

#[derive(Debug, Serialize, Deserialize, Validate)]
pub struct PostInput {
    pub parent_id: Option<Uuid>,
    pub list_id: Uuid,
    pub due_at: PrimitiveDateTime,
    pub due_text: String,
    pub completed: Option<bool>,
    pub title: String,
    pub description: Option<String>,
}

[Mike-Neto]

I'm not sure what you mean with JSON data guards, in any case I've updated the example with a data guard example so you can see that you still need to do some work to indicate to rocket where the data guard should get it's data but otherise the deserialization is done automatically.

#[macro_use]
extern crate rocket;

use rocket::form::Form;
use rocket::http::Status;
use rocket::request::{FromRequest, Outcome, Request};
use rocket::time::PrimitiveDateTime;

#[derive(FromForm, Debug)]
struct Task<'r> {
    name: &'r str,
    due: PrimitiveDateTime,
}

#[rocket::async_trait]
impl<'r> FromRequest<'r> for Task<'r> {
    type Error = String;

    async fn from_request(req: &'r Request<'_>) -> Outcome<Self, Self::Error> {
        let name = req.query_value("name");
        let due = req.query_value("due");
        match (name, due) {
            (Some(Ok(name)), Some(Ok(due))) => {
                Outcome::Success(Task {
                    name,
                    // It gets auto implemented since it implements FromForm Trait,
                    // It makes sense since this could be coming from some header, the query params or segments
                    // so this implementation is required to indicate that, but the deserialization itself is done by
                    // rocket if that makes sense.
                    due,
                })
            }
            (_, _) => Outcome::Failure((
                Status::UnprocessableEntity,
                "It failed to process Task guard".to_string(),
            )),
        }
    }
}

#[post("/", data = "<task>")]
fn index(task: Form<Task<'_>>) -> String {
    format!("{task:?}")
}

#[get("/data")]
fn data(task: Task<'_>) -> String {
    format!("{task:?}")
}

#[launch]
fn rocket() -> _ {
    rocket::build().mount("/", routes![index, data])
}

#[cfg(test)]
mod test {
    use super::rocket;
    use rocket::http::{ContentType, Status};
    use rocket::local::blocking::Client;

    #[test]
    fn it_works() {
        let client = Client::tracked(rocket()).expect("valid rocket instance");
        let response = client
            .post(uri!(super::index))
            .header(ContentType::Form)
            .body("name=Run&due=2023-12-25T11:00")
            .dispatch();
        assert_eq!(response.status(), Status::Ok);
        assert_eq!(
            response.into_string().unwrap(),
            "Form(Task { name: \"Run\", due: 2023-12-25 11:00:00.0 })"
        );
    }

    #[test]
    fn it_works_for_request_guards() {
        let client = Client::tracked(rocket()).expect("valid rocket instance");
        let response = client
            .get(format!(
                "{}?name=Run&due=2023-12-25T11:00",
                uri!(super::data)
            ))
            .dispatch();
        assert_eq!(response.status(), Status::Ok);
        assert_eq!(
            response.into_string().unwrap(),
            "Task { name: \"Run\", due: 2023-12-25 11:00:00.0 }"
        );
    }
}

[Atlinx]

Thanks for the quick response! The JSON guards I'm referring to are the ones you put in the handlers, ie.

#[post("/", data = "<input>", format = "application/json")]
pub fn my_post_handler(input: Json<MyCustomInput>) -> Status {
  ...
}

Turns out the guards do indeed work, however, they serialize/deserialize the time::PrimitiveDateTime type as an array of numbers (years, months, days, hours, minutes, seconds, etc). I wanted my dates to be passed around as an iso string (ie. 2023-10-19T10:23:00.0Z), so I ended up writing my own serde serialize and deserialize functions to override the default behavior provided by the time crate.

use serde::{Deserialize, Deserializer, Serializer};
use time::{format_description::well_known::Iso8601, PrimitiveDateTime};

pub fn primitive_date_iso_serialize<S>(x: &PrimitiveDateTime, s: S) -> Result<S::Ok, S::Error>
where
    S: Serializer,
{
    s.serialize_str(
        &x.assume_utc()
            .format(&Iso8601::DEFAULT)
            .map_err(|_| serde::ser::Error::custom("Failed to serialize date time into iso."))?,
    )
}

pub fn primitive_date_iso_deserialize<'de, D>(
    deserializer: D,
) -> Result<PrimitiveDateTime, D::Error>
where
    D: Deserializer<'de>,
{
    let date_time_str: &str = Deserialize::deserialize(deserializer)?;
    PrimitiveDateTime::parse(date_time_str, &Iso8601::DEFAULT)
        .map_err(|_| serde::de::Error::custom("Failed to parse into date time."))
}

...

#[derive(Debug, Serialize, Deserialize, PartialEq, Eq)]
pub struct GetTaskResponse {
    pub id: Uuid,
    pub parent_id: Option<Uuid>,
    pub list_id: Uuid,
    #[serde(
        serialize_with = "primitive_date_iso_serialize",
        deserialize_with = "primitive_date_iso_deserialize"
    )]
    pub created_at: PrimitiveDateTime,
    #[serde(
        serialize_with = "primitive_date_iso_serialize",
        deserialize_with = "primitive_date_iso_deserialize"
    )]
    pub updated_at: PrimitiveDateTime,
    ...
}