Merge pull request #4 from OSMA-D/refactor

Refactor

src/core.rs

@@ -35,7 +35,7 @@ impl Core {
             salt: env::var("SALT").expect("Hash salt not found"),
         }
     }
-    pub async fn get_apps(&self) -> Vec<Document> {
+    pub async fn get_apps(&self) -> Result<Vec<Document>, serde_json::Value> {
         self.get_collection(&self.apps).await
     }
 
@@ -154,17 +154,20 @@ impl Core {
             .unwrap();
     }
 
-    pub async fn get_reviews(&self, app_id: &String) -> Vec<Document> {
+    pub async fn get_reviews(&self, app_id: &String) -> Result<Vec<Document>, serde_json::Value> {
         self.get_collection_with_params(&self.reviews, doc! {"app_id":app_id})
             .await
     }
 
-    pub async fn get_apps_by_tag(&self, info: &AppTags) -> Vec<Document> {
+    pub async fn get_apps_by_tag(
+        &self,
+        info: &AppTags,
+    ) -> Result<Vec<Document>, serde_json::Value> {
         self.get_collection_with_params(&self.apps, doc! {"tags":{"$in":&info.tags}})
             .await
     }
 
-    pub async fn get_versions(&self, app_id: &String) -> Vec<Document> {
+    pub async fn get_versions(&self, app_id: &String) -> Result<Vec<Document>, serde_json::Value> {
         self.get_collection_with_params_and_sort(
             &self.apps_versions,
             doc! {"app_id":app_id},
@@ -559,40 +562,76 @@ impl Core {
         collection: &Collection<Document>,
         params: Document,
         sort_params: Document,
-    ) -> Vec<Document> {
+    ) -> Result<Vec<Document>, serde_json::Value> {
         let options = FindOptions::builder()
             .projection(doc! {"_id" : 0})
             .sort(sort_params)
             .build();
         let cursor = match collection.find(params, options).await {
             Ok(cursor) => cursor,
-            Err(_) => return vec![],
+            Err(_) => {
+                return Err(json! ({
+                    "code":"err",
+                    "msg":"Error connecting to the database"
+                }))
+            }
         };
 
-        cursor.try_collect().await.unwrap_or_else(|_| vec![])
+        match cursor.try_collect().await {
+            Ok(collection) => Ok(collection),
+            Err(_) => Err(json! ({
+                "code":"err",
+                "msg":"Error connecting to the database"
+            })),
+        }
     }
 
     async fn get_collection_with_params(
         &self,
         collection: &Collection<Document>,
         params: Document,
-    ) -> Vec<Document> {
+    ) -> Result<Vec<Document>, serde_json::Value> {
         let options = FindOptions::builder().projection(doc! {"_id" : 0}).build();
         let cursor = match collection.find(params, options).await {
             Ok(cursor) => cursor,
-            Err(_) => return vec![],
+            Err(_) => {
+                return Err(json! ({
+                    "code":"err",
+                    "msg":"Error connecting to the database"
+                }))
+            }
         };
 
-        cursor.try_collect().await.unwrap_or_else(|_| vec![])
+        match cursor.try_collect().await {
+            Ok(collection) => Ok(collection),
+            Err(_) => Err(json! ({
+                "code":"err",
+                "msg":"Error connecting to the database"
+            })),
+        }
     }
 
-    async fn get_collection(&self, collection: &Collection<Document>) -> Vec<Document> {
+    async fn get_collection(
+        &self,
+        collection: &Collection<Document>,
+    ) -> Result<Vec<Document>, serde_json::Value> {
         let options = FindOptions::builder().projection(doc! {"_id" : 0}).build();
         let cursor = match collection.find(None, options).await {
             Ok(cursor) => cursor,
-            Err(_) => return vec![],
+            Err(_) => {
+                return Err(json! ({
+                    "code":"err",
+                    "msg":"Error connecting to the database"
+                }))
+            }
         };
 
-        cursor.try_collect().await.unwrap_or_else(|_| vec![])
+        match cursor.try_collect().await {
+            Ok(collection) => Ok(collection),
+            Err(_) => Err(json! ({
+                "code":"err",
+                "msg":"Error connecting to the database"
+            })),
+        }
     }
 }

src/routes.rs

@@ -1,6 +1,7 @@
 use crate::types::*;
 use actix_web::{get, post, web, HttpRequest, HttpResponse, Responder};
 use actix_web_grants::proc_macro::has_any_permission;
+use bson::Document;
 
 #[post("/signup")]
 pub async fn signup(app_data: web::Data<crate::AppState>, user: web::Json<User>) -> impl Responder {
@@ -18,7 +19,7 @@ pub async fn signin(
 #[get("/apps")]
 #[has_any_permission("user", "admin")]
 pub async fn apps(app_data: web::Data<crate::AppState>) -> impl Responder {
-    HttpResponse::Ok().json(app_data.core.get_apps().await)
+    resolve_collection(app_data.core.get_apps().await)
 }
 
 #[post("/apps_by_tag")]
@@ -27,7 +28,7 @@ pub async fn apps_by_tags(
     app_data: web::Data<crate::AppState>,
     info: web::Json<AppTags>,
 ) -> impl Responder {
-    HttpResponse::Ok().json(app_data.core.get_apps_by_tag(&info).await)
+    resolve_collection(app_data.core.get_apps_by_tag(&info).await)
 }
 
 #[get("/reviews/{app_id}")]
@@ -36,7 +37,7 @@ pub async fn reviews(
     app_data: web::Data<crate::AppState>,
     app_id: web::Path<String>,
 ) -> impl Responder {
-    HttpResponse::Ok().json(app_data.core.get_reviews(&app_id).await)
+    resolve_collection(app_data.core.get_reviews(&app_id).await)
 }
 
 #[get("/versions/{app_id}")]
@@ -45,7 +46,7 @@ pub async fn versions(
     app_data: web::Data<crate::AppState>,
     app_id: web::Path<String>,
 ) -> impl Responder {
-    HttpResponse::Ok().json(app_data.core.get_versions(&app_id).await)
+    resolve_collection(app_data.core.get_versions(&app_id).await)
 }
 
 #[get("/rating/{app_id}")]
@@ -166,6 +167,13 @@ fn username(req: HttpRequest) -> String {
         .to_string()
 }
 
+fn resolve_collection(resp: Result<Vec<Document>, serde_json::Value>) -> HttpResponse {
+    match resp {
+        Ok(resp) => HttpResponse::Ok().json(resp),
+        Err(e) => HttpResponse::InternalServerError().json(e),
+    }
+}
+
 fn response(result: serde_json::Value) -> impl Responder {
     if result["code"] == "ok" {
         HttpResponse::Ok().json(result)