Implemented get, create, and search with error handling.

Author: timothyhollabaugh

Cargo.toml

@@ -0,0 +1,14 @@
+[package]
+name = "web_dev"
+version = "0.1.0"
+authors = ["Tim <[email protected]>"]
+edition = "2018"
+
+[dependencies]
+rouille = "3.0.0"
+diesel = { version = "1.3.3", features = ["mysql"] }
+dotenv = "0.13.0"
+serde = { version = "1.0", features = ["derive"]}
+serde_json = "1.0"
+log = "0.4"
+simplelog = "0.5"

diesel.toml

@@ -0,0 +1,6 @@
+
+# For documentation on how to configure this file,
+# see diesel.rs/guides/configuring-diesel-cli
+
+[print_schema]
+file = "src/schema.rs

rest_api/delete.http

@@ -0,0 +1,3 @@
+DELETE http://localhost:8000/users/6
+
+###

rest_api/get_all.http

@@ -0,0 +1,3 @@
+GET http://localhost:8000/users
+
+###

rest_api/get_search.http

@@ -0,0 +1,3 @@
+GET http://localhost:8000/users?first_name=timothy&last_name=hollabaut
+
+###

rest_api/insert.http

@@ -0,0 +1,5 @@
+POST http://localhost:8000/users/create
+
+{ "first_name": "timothy", "last_name": "hollabaut", "email": "[email protected]", "banner_id": 916246947 }
+
+###

src/errors.rs

@@ -0,0 +1,84 @@
+use std::convert::From;
+use std::error::Error;
+use std::fmt;
+
+#[derive(Debug, Copy, Clone)]
+pub enum WebdevErrorKind {
+    Database,
+    Format,
+    NotFound,
+}
+
+#[derive(Debug)]
+pub struct WebdevError {
+    kind: WebdevErrorKind,
+    source: Option<Box<dyn Error>>,
+}
+
+impl std::fmt::Display for WebdevError {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        match self.kind {
+            WebdevErrorKind::Database => write!(f, "Database error!"),
+            WebdevErrorKind::Format => write!(f, "Format error!"),
+            WebdevErrorKind::NotFound => write!(f, "Not found!"),
+        }
+    }
+}
+
+impl Error for WebdevError {
+    fn source(&self) -> Option<&(dyn Error + 'static)> {
+        match self.source {
+            Some(ref e) => Some(e.as_ref()),
+            None => None,
+        }
+    }
+}
+
+impl WebdevError {
+    pub fn new(kind: WebdevErrorKind) -> WebdevError {
+        WebdevError { kind, source: None }
+    }
+
+    pub fn with_source(kind: WebdevErrorKind, source: Box<dyn Error>) -> WebdevError {
+        WebdevError {
+            kind,
+            source: Some(source),
+        }
+    }
+
+    pub fn kind(&self) -> WebdevErrorKind {
+        return self.kind;
+    }
+}
+
+impl From<diesel::result::Error> for WebdevError {
+    fn from(d: diesel::result::Error) -> WebdevError {
+        WebdevError::with_source(WebdevErrorKind::Database, Box::new(d))
+    }
+}
+
+impl From<serde_json::Error> for WebdevError {
+    fn from(s: serde_json::Error) -> WebdevError {
+        WebdevError::with_source(WebdevErrorKind::Format, Box::new(s))
+    }
+}
+
+impl From<std::num::ParseIntError> for WebdevError {
+    fn from(s: std::num::ParseIntError) -> WebdevError {
+        WebdevError::with_source(WebdevErrorKind::Format, Box::new(s))
+    }
+}
+
+impl From<WebdevError> for rouille::Response {
+    fn from(e: WebdevError) -> rouille::Response {
+        match e.kind() {
+            WebdevErrorKind::NotFound => {
+                rouille::Response::text(e.to_string()).with_status_code(404)
+            }
+            WebdevErrorKind::Format => rouille::Response::text(e.to_string()).with_status_code(400),
+            WebdevErrorKind::Database => {
+                rouille::Response::text(e.to_string()).with_status_code(500)
+            }
+        }
+    }
+}

src/main.rs

@@ -0,0 +1,175 @@
+#[macro_use]
+extern crate diesel;
+
+use std::env;
+use std::error::Error;
+use std::sync::Mutex;
+
+use log::debug;
+use log::error;
+use log::info;
+use log::trace;
+use log::warn;
+
+use diesel::expression::AsExpression;
+use diesel::prelude::*;
+use diesel::query_builder::AsQuery;
+use diesel::MysqlConnection;
+
+use rouille::router;
+
+use serde;
+use serde_json;
+
+use dotenv::dotenv;
+
+use self::errors::WebdevError;
+use self::errors::WebdevErrorKind;
+use self::schema::users;
+
+mod errors;
+mod models;
+mod schema;
+
+fn main() {
+    dotenv().ok();
+
+    simplelog::TermLogger::init(simplelog::LevelFilter::Trace, simplelog::Config::default())
+        .unwrap();
+
+    info!("Connecting to database");
+
+    let database_url = env::var("DATABASE_URL").expect("DATABSE_URL needs to be set");
+
+    debug!("Connecting to {}", database_url);
+
+    let connection = match MysqlConnection::establish(&database_url) {
+        Ok(c) => c,
+        Err(e) => {
+            error!("Could not connect to database: {}", e);
+            return;
+        }
+    };
+
+    debug!("Connected to database");
+
+    let connection_mutex = Mutex::new(connection);
+
+    info!("Starting server on 0.0.0.0:8000");
+
+    rouille::start_server("0.0.0.0:8000", move |request| {
+        debug!(
+            "Handling request {} {} from {}",
+            request.method(),
+            request.url(),
+            request.remote_addr()
+        );
+
+        let current_connection = match connection_mutex.lock() {
+            Ok(c) => c,
+            Err(_e) => {
+                error!("Could not lock database");
+                return rouille::Response::from(WebdevError::new(WebdevErrorKind::Database));
+            }
+        };
+
+        let response = handle_request(request, &current_connection);
+
+        match response {
+            Ok(json) => {
+                if let Some(j) = json {
+                    rouille::Response::json(&j)
+                } else {
+                    rouille::Response::empty_204()
+                }
+            }
+            Err(e) => {
+                if let Some(err_source) = e.source() {
+                    error!("Error processing request: {}", err_source);
+                } else {
+                    error!("Error processing request");
+                }
+
+                rouille::Response::from(e)
+            }
+        }
+    });
+}
+
+fn handle_request(
+    request: &rouille::Request,
+    database_connection: &MysqlConnection,
+) -> Result<Option<String>, WebdevError> {
+    router!(request,
+        (GET) (/users) => {
+            handle_get(
+                request.get_param("first_name"),
+                request.get_param("last_name"),
+                if let Some(p) = request.get_param("banner_id") { Some(p.parse()?) } else { None },
+                request.get_param("email"),
+                database_connection
+            ).map(|s| Some(s))
+        },
+        (POST) (/users/create) => {
+            let request_body = request.data().ok_or(WebdevError::new(WebdevErrorKind::Format))?;
+            let new_user: models::NewUser = serde_json::from_reader(request_body)?;
+
+            handle_insert(new_user, database_connection).map(|s| Some(s))
+        },
+        (DELETE) (/users/{id: u64}) => {
+            handle_delete(id, database_connection).map(|_| None)
+        },
+        _ => Err(WebdevError::new(WebdevErrorKind::NotFound))
+    )
+}
+
+fn handle_get(
+    first_name_filter: Option<String>,
+    last_name_filter: Option<String>,
+    banner_id_filter: Option<u32>,
+    email_filter: Option<String>,
+    database_connection: &MysqlConnection,
+) -> Result<String, WebdevError> {
+    let mut users_query = users::table.as_query().into_boxed();
+
+    if let Some(p) = first_name_filter {
+        users_query = users_query.filter(users::first_name.eq(p));
+    }
+
+    if let Some(p) = last_name_filter {
+        users_query = users_query.filter(users::last_name.eq(p));
+    }
+
+    if let Some(p) = banner_id_filter {
+        users_query = users_query.filter(users::banner_id.eq(p));
+    }
+
+    if let Some(p) = email_filter {
+        users_query = users_query.filter(users::email.eq(p));
+    }
+
+    let all_users = users_query.load::<models::User>(database_connection)?;
+    Ok(serde_json::to_string(&all_users)?)
+}
+
+fn handle_insert(
+    new_user: models::NewUser,
+    database_connection: &MysqlConnection,
+) -> Result<String, WebdevError> {
+
+    diesel::insert_into(users::table)
+        .values(new_user)
+        .execute(database_connection)?;
+
+    let inserted_user = users::table
+        .filter(diesel::dsl::sql("id = LAST_INSERT_ID()"))
+        .load::<models::User>(database_connection)?;
+
+    Ok(serde_json::to_string(&inserted_user)?)
+}
+
+fn handle_delete(id: u64, database_connection: &MysqlConnection) -> Result<(), WebdevError> {
+    diesel::delete(users::table.filter(users::id.eq(id))).execute(database_connection)?;
+
+    Ok(())
+}

src/models.rs

@@ -0,0 +1,23 @@
+use diesel::Queryable;
+use serde::Deserialize;
+use serde::Serialize;
+
+use super::schema::users;
+
+#[derive(Queryable, Serialize, Deserialize)]
+pub struct User {
+    pub id: u64,
+    pub first_name: String,
+    pub last_name: String,
+    pub banner_id: u32,
+    pub email: Option<String>,
+}
+
+#[derive(Insertable, Serialize, Deserialize)]
+#[table_name = "users"]
+pub struct NewUser {
+    pub first_name: String,
+    pub last_name: String,
+    pub banner_id: u32,
+    pub email: Option<String>,
+}

src/schema.rs

@@ -0,0 +1,9 @@
+table! {
+    users (id) {
+        id -> Unsigned<Bigint>,
+        first_name -> Varchar,
+        last_name -> Varchar,
+        banner_id -> Unsigned<Integer>,
+        email -> Nullable<Varchar>,
+    }
+}