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 143 144 145 146 147 148 149 150
extern crate serde; extern crate serde_json; use std::ops::{Deref, DerefMut}; use std::io::Read; use rocket::outcome::Outcome; use rocket::request::Request; use rocket::data::{self, Data, FromData}; use rocket::response::{self, Responder, content}; use rocket::http::Status; use self::serde::{Serialize, Deserialize}; use self::serde_json::error::Error as SerdeError; /// The JSON type, which implements `FromData` and `Responder`. This type allows /// you to trivially consume and respond with JSON in your Rocket application. /// /// If you're receiving JSON data, simple add a `data` parameter to your route /// arguments and ensure the type o the parameter is a `JSON<T>`, where `T` is /// some type you'd like to parse from JSON. `T` must implement `Deserialize` /// from [Serde](https://github.com/serde-rs/json). The data is parsed from the /// HTTP request body. /// /// ```rust,ignore /// #[post("/users/", format = "application/json", data = "<user>")] /// fn new_user(user: JSON<User>) { /// ... /// } /// ``` /// You don't _need_ to use `format = "application/json"`, but it _may_ be what /// you want. Using `format = application/json` means that any request that /// doesn't specify "application/json" as its first `Content-Type:` header /// parameter will not be routed to this handler. /// /// If you're responding with JSON data, return a `JSON<T>` type, where `T` /// implements `Serialize` from [Serde](https://github.com/serde-rs/json). The /// content type of the response is set to `application/json` automatically. /// /// ```rust,ignore /// #[get("/users/<id>")] /// fn user(id: usize) -> JSON<User> { /// let user_from_id = User::from(id); /// ... /// JSON(user_from_id) /// } /// ``` /// #[derive(Debug)] pub struct JSON<T>(pub T); impl<T> JSON<T> { /// Consumes the JSON wrapper and returns the wrapped item. /// /// # Example /// ```rust /// # use rocket_contrib::JSON; /// let string = "Hello".to_string(); /// let my_json = JSON(string); /// assert_eq!(my_json.unwrap(), "Hello".to_string()); /// ``` pub fn unwrap(self) -> T { self.0 } } /// Maximum size of JSON is 1MB. /// TODO: Determine this size from some configuration parameter. const MAX_SIZE: u64 = 1048576; impl<T: Deserialize> FromData for JSON<T> { type Error = SerdeError; fn from_data(request: &Request, data: Data) -> data::Outcome<Self, SerdeError> { if !request.content_type().is_json() { error_!("Content-Type is not JSON."); return Outcome::Forward(data); } let reader = data.open().take(MAX_SIZE); match serde_json::from_reader(reader).map(|val| JSON(val)) { Ok(value) => Outcome::Success(value), Err(e) => { error_!("Couldn't parse JSON body: {:?}", e); Outcome::Failure((Status::BadRequest, e)) } } } } // Serializes the wrapped value into JSON. Returns a response with Content-Type // JSON and a fixed-size body with the serialization. If serialization fails, an // `Err` of `Status::InternalServerError` is returned. impl<T: Serialize> Responder<'static> for JSON<T> { fn respond(self) -> response::Result<'static> { serde_json::to_string(&self.0).map(|string| { content::JSON(string).respond().unwrap() }).map_err(|e| { error_!("JSON failed to serialize: {:?}", e); Status::InternalServerError }) } } impl<T> Deref for JSON<T> { type Target = T; fn deref<'a>(&'a self) -> &'a T { &self.0 } } impl<T> DerefMut for JSON<T> { fn deref_mut<'a>(&'a mut self) -> &'a mut T { &mut self.0 } } /// A nice little macro to create simple HashMaps. Really convenient for /// returning ad-hoc JSON messages. /// /// # Examples /// /// ``` /// # #[macro_use] extern crate rocket_contrib; /// use std::collections::HashMap; /// # fn main() { /// let map: HashMap<&str, usize> = map! { /// "status" => 0, /// "count" => 100 /// }; /// /// assert_eq!(map.len(), 2); /// assert_eq!(map.get("status"), Some(&0)); /// assert_eq!(map.get("count"), Some(&100)); /// # } /// ``` #[macro_export] macro_rules! map { ($($key:expr => $value:expr),+) => ({ use std::collections::HashMap; let mut map = HashMap::new(); $(map.insert($key, $value);)+ map }); ($($key:expr => $value:expr),+,) => { map!($($key => $value),+) }; }