Allow creating gists

src/gists/mod.rs

     pub body: String,
 }
 
+#[derive(Insertable, Serialize, Deserialize)]
+#[table_name = "gists"]
+pub struct InsertableGist {
+    pub title: String,
+    pub body: String,
+}
+
 pub fn all(connection: &PGC) -> QueryResult<Vec<Gist>> {
     gists::table.load::<Gist>(&*connection)
 }
 pub fn get(connection: &PGC, id: i32) -> QueryResult<Gist> {
     gists::table.find(id).get_result::<Gist>(connection)
 }
+
+pub fn insert(gist: InsertableGist, connection: &PGC) -> QueryResult<Gist> {
+    diesel::insert_into(gists::table)
+        .values(gist)
+        .get_result(connection)
+}

src/main.rs

 mod routes;
 mod schema;
 
+use crate::routes::static_rocket_route_info_for_create_gist;
 use crate::routes::static_rocket_route_info_for_index;
 use crate::routes::static_rocket_route_info_for_show_gist;
 
     rocket::ignite()
         .attach(Template::fairing())
         .manage(connection::init_pool())
-        .mount("/", routes![index, show_gist])
+        .mount("/", routes![index, show_gist, create_gist])
         .launch();
 }

src/routes.rs

 use diesel::result::Error;
 use rocket::http::Status;
+use rocket::response::status;
 use rocket_contrib::json::Json;
 use rocket_contrib::templates::Template;
 use std::collections::HashMap;
 
 use crate::connection::DbConn;
 use crate::gists;
-use crate::gists::Gist;
+use crate::gists::{Gist, InsertableGist};
 
-fn error_status(error: Error) -> Status {
+fn error_response(error: Error) -> Status {
     match error {
         Error::NotFound => Status::NotFound,
         _ => Status::InternalServerError,
 pub fn index(connection: DbConn) -> Result<Json<Vec<Gist>>, Status> {
     gists::all(&connection)
         .map(|gists| Json(gists))
-        .map_err(|error| error_status(error))
+        .map_err(|error| error_response(error))
 }
 
 #[get("/gists/<id>")]
     context.insert("gist", gist);
     Template::render("gists/show", &context)
 }
+
+#[post("/api/gists", format = "application/json", data = "<gist>")]
+pub fn create_gist<'a>(
+    gist: Json<InsertableGist>,
+    connection: DbConn,
+) -> Result<status::Created<Json<Gist>>, Status> {
+    gists::insert(gist.into_inner(), &connection)
+        .map(|gist| status::Created(String::from(""), Some(Json(gist))))
+        .map_err(|error| error_response(error))
+}