Error handling

backend/src/airports/routes.rs

@@ -1,38 +1,66 @@
 use crate::airports::{Airport, Airports};
 use crate::error_handler::CustomError;
 use actix_web::{delete, get, post, put, web, HttpResponse};
+use log::error;
 use serde_json::json;
 
 #[get("/airports")]
 async fn find_all() -> Result<HttpResponse, CustomError> {
-  let airports = web::block(|| Airports::find_all()).await.unwrap();
+    let airports = match web::block(|| Airports::find_all()).await.unwrap() {
+        Ok(a) => a,
+        Err(err) => {
+            error!("{}", err);
+            return Err(err);
+        }
+    };
     Ok(HttpResponse::Ok().json(airports))
 }
 
 #[get("/airports/{id}")]
 async fn find(id: web::Path<i32>) -> Result<HttpResponse, CustomError> {
-    let airport = Airports::find(id.into_inner())?;
+    let airport = match Airports::find(id.into_inner()) {
+        Ok(a) => a,
+        Err(err) => {
+            error!("{}", err);
+            return Err(err);
+        }
+    };
     Ok(HttpResponse::Ok().json(airport))
 }
 
 #[post("/airports")]
 async fn create(airport: web::Json<Airport>) -> Result<HttpResponse, CustomError> {
-    let airport = Airports::create(airport.into_inner())?;
+    let airport = match Airports::create(airport.into_inner()) {
+        Ok(a) => a,
+        Err(err) => {
+            error!("{}", err);
+            return Err(err);
+        }
+    };
     Ok(HttpResponse::Ok().json(airport))
 }
 
 #[put("/airports/{id}")]
-async fn update(
-    id: web::Path<i32>,
-    airport: web::Json<Airport>,
-) -> Result<HttpResponse, CustomError> {
-    let airport = Airports::update(id.into_inner(), airport.into_inner())?;
+async fn update(id: web::Path<i32>, airport: web::Json<Airport>) -> Result<HttpResponse, CustomError> {
+    let airport = match Airports::update(id.into_inner(), airport.into_inner()) {
+        Ok(a) => a,
+        Err(err) => {
+            error!("{}", err);
+            return Err(err);
+        }
+    };
     Ok(HttpResponse::Ok().json(airport))
 }
 
 #[delete("/airports/{id}")]
 async fn delete(id: web::Path<i32>) -> Result<HttpResponse, CustomError> {
-    let deleted_airport = Airports::delete(id.into_inner())?;
+    let deleted_airport = match Airports::delete(id.into_inner()) {
+        Ok(a) => a,
+        Err(err) => {
+            error!("{}", err);
+            return Err(err);
+        }
+    };
     Ok(HttpResponse::Ok().json(json!({ "deleted": deleted_airport })))
 }
 

backend/src/main.rs

@@ -3,9 +3,11 @@ extern crate diesel;
 #[macro_use]
 extern crate diesel_migrations;
 
-use actix_web::{App, HttpServer};
+use actix_cors::Cors;
+use actix_web::{App, HttpServer, middleware::Logger};
 use dotenv::dotenv;
 use listenfd::ListenFd;
+use log::debug;
 use std::env;
 
 mod airports;
@@ -17,20 +19,31 @@ mod schema;
 #[actix_rt::main]
 async fn main() -> std::io::Result<()> {
     dotenv().ok();
+    if std::env::var_os("RUST_LOG").is_none() {
+        std::env::set_var("RUST_LOG", "info,actix=info,diesel_migrations=warn,reqwest=warn,hyper=warn");
+    }
     env_logger::init();
     db::init();
 
     let mut listenfd = ListenFd::from_env();
-    let mut server = HttpServer::new(|| App::new()
+    let mut server = HttpServer::new(|| {
+        let cors = Cors::default()
+            .allow_any_origin()
+            .allow_any_method()
+            .allow_any_header();
+        App::new()
         .configure(airports::init_routes)
         .configure(metars::init_routes)
-    );
+        .wrap(cors)
+        .wrap(Logger::default())
+    });
 
     server = match listenfd.take_tcp_listener(0)? {
         Some(listener) => server.listen(listener)?,
         None => {
             let host = env::var("HOST").expect("Please set host in .env");
             let port = env::var("PORT").expect("Please set port in .env");
+            debug!("Binding server to {}:{}", host, port);
             server.bind(format!("{}:{}", host, port))?
         }
     };

backend/src/metars/routes.rs

@@ -1,16 +1,27 @@
 use crate::error_handler::CustomError;
 use crate::metars::Metars;
-use actix_web::{get, web, HttpResponse};
+use actix_web::{get, web, HttpResponse, Responder};
+
+// #[get("metars/{ids}")]
+// async fn get_all(ids: web::Path<String>) -> Result<HttpResponse, CustomError> {
+//     let airports = web::block(|| Ok::<_, CustomError>(async {Metars::get_all(ids.into_inner()).await}))
+//         .await
+//         .unwrap()
+//         .unwrap()
+//         .await
+//         .unwrap();
+//     Ok(HttpResponse::Ok().json(airports))
+// }
 
 #[get("metars/{ids}")]
-async fn get_all(ids: web::Path<String>) -> Result<HttpResponse, CustomError> {
+async fn get_all(ids: web::Path<String>) -> impl Responder {
     let airports = web::block(|| Ok::<_, CustomError>(async {Metars::get_all(ids.into_inner()).await}))
         .await
         .unwrap()
         .unwrap()
         .await
         .unwrap();
-    Ok(HttpResponse::Ok().json(airports))
+    HttpResponse::Ok().json(airports)
 }
 
 pub fn init_routes(config: &mut web::ServiceConfig) {