feat: extract route-specific logic from mod.rs, add 2 custom error variants, better error handling

Route-specific logic has been extracted from controllers/mod.rs into the
corresponding controllers

2 new CustomError variants: Notfound(for when a route is correct, but no
data is returned) and ServiceUnavailable(for when a connection to the
database cannot be established), both with a customized error message
that includes the error based on status code and details given by the
user

The DB name is now set from an env variable, DATABASE_NAME, and all env
variable logic has been moved to main.rs, as well as critical error
handling(panicking)

Author: pml68

src/controllers/contactinfo_controller.rs

@@ -1,19 +1,49 @@
 use crate::{
-    controllers::MongoRepo, custom::error::CustomError, models::contactinfo_model::Contactinfo,
+    controllers::{MongoRepo, DB_CON_ERR},
+    custom::error::CustomError,
+    models::contactinfo_model::Contactinfo,
 };
+use mongodb::{bson::doc, options::FindOptions, sync::Collection};
 use rocket::{http::Status, serde::json::Json, State};
 
+impl MongoRepo {
+    pub fn get_contactinfo(&self) -> Result<Vec<Contactinfo>, String> {
+        let col: Collection<Contactinfo> = self.db.collection("contactinfo");
+        let cursors = match col
+            .find(
+                None,
+                FindOptions::builder()
+                    .projection(doc! {"_id":0})
+                    .sort(doc! {"_id": 1})
+                    .build(),
+            )
+            .ok()
+        {
+            Some(c) => c,
+            None => return Err(DB_CON_ERR.to_string()),
+        };
+        let contactinfo = cursors.map(|doc| doc.unwrap()).collect();
+        Ok(contactinfo)
+    }
+}
+
 #[get("/contactinfo")]
 pub fn get_contactinfo(db: &State<MongoRepo>) -> Result<Json<Vec<Contactinfo>>, CustomError> {
     let contactinfo = db.get_contactinfo();
     match contactinfo {
         Ok(contactinfo) => {
             if contactinfo.is_empty() {
-                Err(CustomError::Default(Status::NotFound))
+                Err(CustomError::NotFound(
+                    Status::NotFound,
+                    "contactinfo".to_string(),
+                ))
             } else {
                 Ok(Json(contactinfo))
             }
         }
-        Err(_) => Err(CustomError::Default(Status::InternalServerError)),
+        Err(error) => Err(CustomError::ServiceUnavailable(
+            Status::ServiceUnavailable,
+            error,
+        )),
     }
 }

src/controllers/location_controller.rs

@@ -1,17 +1,46 @@
-use crate::{controllers::MongoRepo, custom::error::CustomError, models::location_model::Location};
+use crate::{
+    controllers::{MongoRepo, DB_CON_ERR},
+    custom::error::CustomError,
+    models::location_model::Location,
+};
+use mongodb::{bson::doc, options::FindOptions, sync::Collection};
 use rocket::{http::Status, serde::json::Json, State};
 
+impl MongoRepo {
+    pub fn get_locations(&self) -> Result<Vec<Location>, String> {
+        let col: Collection<Location> = self.db.collection("locations");
+        let cursors = match col
+            .find(
+                None,
+                FindOptions::builder().projection(doc! {"_id":0}).build(),
+            )
+            .ok()
+        {
+            Some(c) => c,
+            None => return Err(DB_CON_ERR.to_string()),
+        };
+        let locations = cursors.map(|doc| doc.unwrap()).collect();
+        Ok(locations)
+    }
+}
+
 #[get("/locations")]
 pub fn get_locations(db: &State<MongoRepo>) -> Result<Json<Vec<Location>>, CustomError> {
     let locations = db.get_locations();
     match locations {
         Ok(locations) => {
             if locations.is_empty() {
-                Err(CustomError::Default(Status::NotFound))
+                Err(CustomError::NotFound(
+                    Status::NotFound,
+                    "locations".to_string(),
+                ))
             } else {
                 Ok(Json(locations))
             }
         }
-        Err(_) => Err(CustomError::Default(Status::InternalServerError)),
+        Err(error) => Err(CustomError::ServiceUnavailable(
+            Status::ServiceUnavailable,
+            error,
+        )),
     }
 }

src/controllers/mod.rs

@@ -3,85 +3,21 @@ pub mod location_controller;
 pub mod notification_controller;
 pub mod service_controller;
 
-use std::env;
-extern crate dotenv;
-use dotenv::dotenv;
-
-use crate::models::{
-    contactinfo_model::Contactinfo, location_model::Location, notification_model::Notification,
-    service_model::Service,
-};
 use mongodb::{
-    bson::{doc, extjson::de::Error},
-    options::FindOptions,
-    sync::{Client, Collection, Database},
+    error::Error,
+    sync::{Client, Database},
 };
 
+pub const DB_CON_ERR: &str = "Couldn't connect to database";
+
 pub struct MongoRepo {
     db: Database,
 }
 
 impl MongoRepo {
-    pub fn init() -> Self {
-        dotenv().ok();
-        let uri = match env::var("DATABASE_URL") {
-            Ok(v) => v.to_string(),
-            Err(_) => format!("Error loading env variable"),
-        };
-        let client = Client::with_uri_str(uri).unwrap();
-        let db = client.database("obs");
-        MongoRepo { db }
-    }
-
-    pub fn get_locations(&self) -> Result<Vec<Location>, Error> {
-        let col: Collection<Location> = self.db.collection("locations");
-        let cursors = col
-            .find(
-                None,
-                FindOptions::builder().projection(doc! {"_id":0}).build(),
-            )
-            .ok()
-            .expect("Error fetching locations");
-        let locations = cursors.map(|doc| doc.unwrap()).collect();
-        Ok(locations)
-    }
-
-    pub fn get_contactinfo(&self) -> Result<Vec<Contactinfo>, Error> {
-        let col: Collection<Contactinfo> = self.db.collection("contactinfo");
-        let cursors = col
-            .find(
-                None,
-                FindOptions::builder()
-                    .projection(doc! {"_id":0})
-                    .sort(doc! {"_id": 1})
-                    .build(),
-            )
-            .ok()
-            .expect("Error fetching contactinfo");
-        let contactinfo = cursors.map(|doc| doc.unwrap()).collect();
-        Ok(contactinfo)
-    }
-
-    pub fn get_services(&self) -> Result<Vec<Service>, Error> {
-        let col: Collection<Service> = self.db.collection("services");
-        let cursors = col
-            .find(
-                None,
-                FindOptions::builder().projection(doc! {"_id":0}).build(),
-            )
-            .ok()
-            .expect("Error fetching services");
-        let services = cursors.map(|doc| doc.unwrap()).collect();
-        Ok(services)
-    }
-
-    pub fn get_notifications(&self) -> Result<Vec<Notification>, Error> {
-        let col: Collection<Notification> = self.db.collection("notifications");
-        let cursors = col
-            .find(None, None)
-            .ok()
-            .expect("Error fetching notifications");
-        let notifications = cursors.map(|doc| doc.unwrap()).collect();
-        Ok(notifications)
+    pub fn init(db_name: String, uri: String) -> Result<Self, Error> {
+        let client = Client::with_uri_str(uri)?;
+        let db = client.database(&db_name);
+        Ok(MongoRepo { db })
     }
 }

src/controllers/notification_controller.rs

@@ -1,19 +1,40 @@
 use crate::{
-    controllers::MongoRepo, custom::error::CustomError, models::notification_model::Notification,
+    controllers::{MongoRepo, DB_CON_ERR},
+    custom::error::CustomError,
+    models::notification_model::Notification,
 };
+use mongodb::{bson::doc, sync::Collection};
 use rocket::{http::Status, serde::json::Json, State};
 
+impl MongoRepo {
+    pub fn get_notifications(&self) -> Result<Vec<Notification>, String> {
+        let col: Collection<Notification> = self.db.collection("notifications");
+        let cursors = match col.find(None, None).ok() {
+            Some(c) => c,
+            None => return Err(DB_CON_ERR.to_string()),
+        };
+        let notifications = cursors.map(|doc| doc.unwrap()).collect();
+        Ok(notifications)
+    }
+}
+
 #[get("/notifications")]
 pub fn get_notifications(db: &State<MongoRepo>) -> Result<Json<Vec<Notification>>, CustomError> {
     let notifications = db.get_notifications();
     match notifications {
         Ok(notifications) => {
             if notifications.is_empty() {
-                Err(CustomError::Default(Status::NotFound))
+                Err(CustomError::NotFound(
+                    Status::NotFound,
+                    "notifications".to_string(),
+                ))
             } else {
                 Ok(Json(notifications))
             }
         }
-        Err(_) => Err(CustomError::Default(Status::InternalServerError)),
+        Err(error) => Err(CustomError::ServiceUnavailable(
+            Status::ServiceUnavailable,
+            error,
+        )),
     }
 }

src/controllers/service_controller.rs

@@ -1,17 +1,46 @@
-use crate::{controllers::MongoRepo, custom::error::CustomError, models::service_model::Service};
+use crate::{
+    controllers::{MongoRepo, DB_CON_ERR},
+    custom::error::CustomError,
+    models::service_model::Service,
+};
+use mongodb::{bson::doc, options::FindOptions, sync::Collection};
 use rocket::{http::Status, serde::json::Json, State};
 
+impl MongoRepo {
+    pub fn get_services(&self) -> Result<Vec<Service>, String> {
+        let col: Collection<Service> = self.db.collection("services");
+        let cursors = match col
+            .find(
+                None,
+                FindOptions::builder().projection(doc! {"_id":0}).build(),
+            )
+            .ok()
+        {
+            Some(c) => c,
+            None => return Err(DB_CON_ERR.to_string()),
+        };
+        let services = cursors.map(|doc| doc.unwrap()).collect();
+        Ok(services)
+    }
+}
+
 #[get("/services")]
 pub fn get_services(db: &State<MongoRepo>) -> Result<Json<Vec<Service>>, CustomError> {
     let services = db.get_services();
     match services {
         Ok(services) => {
             if services.is_empty() {
-                Err(CustomError::Default(Status::NotFound))
+                Err(CustomError::NotFound(
+                    Status::NotFound,
+                    "services".to_string(),
+                ))
             } else {
                 Ok(Json(services))
             }
         }
-        Err(_) => Err(CustomError::Default(Status::InternalServerError)),
+        Err(error) => Err(CustomError::ServiceUnavailable(
+            Status::ServiceUnavailable,
+            error,
+        )),
     }
 }

src/custom/error.rs

@@ -21,12 +21,16 @@ pub struct Error {
 
 #[derive(Debug, Clone)]
 pub enum CustomError {
+    NotFound(Status, String),
+    ServiceUnavailable(Status, String),
     Default(Status),
 }
 
 impl CustomError {
     fn get_http_status(&self) -> Status {
         match self {
+            CustomError::NotFound(status, _) => *status,
+            CustomError::ServiceUnavailable(status, _) => *status,
             CustomError::Default(status) => *status,
         }
     }
@@ -45,10 +49,32 @@ impl<'r> Responder<'r, 'static> for CustomError {
                 error: Error {
                     status: status.code,
                     message: status.reason().unwrap().to_string(),
-                    cat: format!("https://http.cat/{}.jpg", status),
+                    cat: format!("https://http.cat/{}.jpg", status.code),
                 },
             })
             .unwrap(),
+            CustomError::NotFound(status, details) => serde::json::to_string(&ErrorResponse {
+                error: Error {
+                    status: status.code,
+                    message: format!(
+                        "{} (No available {})",
+                        status.reason().unwrap().to_string(),
+                        details
+                    ),
+                    cat: format!("https://http.cat/{}.jpg", status.code),
+                },
+            })
+            .unwrap(),
+            CustomError::ServiceUnavailable(status, details) => {
+                serde::json::to_string(&ErrorResponse {
+                    error: Error {
+                        status: status.code,
+                        message: format!("{} ({})", status.reason().unwrap().to_string(), details),
+                        cat: format!("https://http.cat/{}.jpg", status.code),
+                    },
+                })
+                .unwrap()
+            }
         };
 
         Response::build()

src/main.rs

@@ -2,6 +2,10 @@ mod controllers;
 mod custom;
 mod models;
 
+use std::env;
+extern crate dotenv;
+use dotenv::dotenv;
+
 #[macro_use]
 extern crate rocket;
 use rocket::{http::Status, Request};
@@ -14,13 +18,27 @@ use crate::controllers::MongoRepo;
 use custom::error::CustomError;
 
 #[catch(default)]
-fn default_catcher(status: Status, req: &Request) -> Option<CustomError> {
+fn default_catcher(status: Status, _: &Request) -> Option<CustomError> {
     Some(CustomError::Default(status))
 }
 
 #[launch]
 fn rocket() -> _ {
-    let db = MongoRepo::init();
+    dotenv().ok();
+    let uri = match env::var("DATABASE_URL") {
+        Ok(v) => v.to_string(),
+        Err(_) => panic!("Couldn't load env variable: DATABASE_URL"),
+    };
+
+    let db_name = match env::var("DATABASE_NAME") {
+        Ok(v) => v.to_string(),
+        Err(_) => panic!("Couldn't load env variable: DATABASE_NAME"),
+    };
+
+    let db = match MongoRepo::init(db_name, uri) {
+        Ok(db) => db,
+        Err(_) => panic!("Couldn't connect to database"),
+    };
     rocket::build()
         .register("/", catchers![default_catcher])
         .manage(db)

src/models/notification_model.rs

@@ -3,7 +3,7 @@ use serde::{Deserialize, Serialize};
 
 #[derive(Debug, Serialize, Deserialize)]
 pub struct Notification {
-    pub _id: Option<ObjectId>,
+    pub _id: ObjectId,
     pub notif_type: String,
     pub date: String,
     pub description: String,