Return a valid structure of the API response

Author: Filip-L

fplus-http-server/src/router/application.rs

@@ -2,9 +2,7 @@ use actix_web::{
     error::{ErrorBadRequest, ErrorInternalServerError, ErrorNotFound},
     get, post, web, HttpResponse, Responder,
 };
-use fplus_database::database::applications::{
-    get_allocator_closed_applications, get_closed_applications,
-};
+
 use fplus_lib::core::{
     application::file::{StorageProviderChangeVerifier, VerifierInput},
     ApplicationQueryParams, BranchDeleteInfo, CompleteGovernanceReviewInfo,
@@ -39,7 +37,7 @@ pub async fn single(
 
 #[get("/applications/closed")]
 pub async fn closed_applications() -> actix_web::Result<impl Responder> {
-    let apps = get_closed_applications()
+    let apps = LDNApplication::get_closed_applications()
         .await
         .map_err(ErrorInternalServerError)?;
 
@@ -54,7 +52,7 @@ pub async fn closed_allocator_applications(
     query: web::Query<GithubQueryParams>,
 ) -> actix_web::Result<impl Responder> {
     let GithubQueryParams { owner, repo } = query.into_inner();
-    let apps = get_allocator_closed_applications(&owner, &repo)
+    let apps = LDNApplication::get_allocator_closed_applications(&owner, &repo)
         .await
         .map_err(ErrorInternalServerError)?;
 

fplus-lib/src/core/mod.rs

@@ -513,19 +513,55 @@ impl LDNApplication {
     }
 
     pub async fn all_applications() -> Result<Vec<ApplicationResponse>, LDNError> {
-        let db_apps = database::applications::get_active_applications()
+        let applications = database::applications::get_active_applications()
             .await
             .map_err(|e| {
                 LDNError::Load(format!(
                     "Failed to get applications from the database: {}",
                     e
                 ))
             })?;
-        let mut all_apps: Vec<ApplicationResponse> = Vec::new();
-        for app in db_apps {
+        let applications_response = Self::prepare_applications_response(applications);
+        Ok(applications_response)
+    }
+
+    pub async fn get_closed_applications() -> Result<Vec<ApplicationResponse>, LDNError> {
+        let applications = database::applications::get_closed_applications()
+            .await
+            .map_err(|e| {
+                LDNError::Load(format!(
+                    "Failed to get applications from the database: {}",
+                    e
+                ))
+            })?;
+        let applications_response = Self::prepare_applications_response(applications);
+        Ok(applications_response)
+    }
+
+    pub async fn get_allocator_closed_applications(
+        owner: &str,
+        repo: &str,
+    ) -> Result<Vec<ApplicationResponse>, LDNError> {
+        let applications = database::applications::get_allocator_closed_applications(owner, repo)
+            .await
+            .map_err(|e| {
+                LDNError::Load(format!(
+                    "Failed to get applications from the database: {}",
+                    e
+                ))
+            })?;
+        let applications_response = Self::prepare_applications_response(applications);
+        Ok(applications_response)
+    }
+
+    fn prepare_applications_response(
+        applications: Vec<ApplicationModel>,
+    ) -> Vec<ApplicationResponse> {
+        let mut applications_response: Vec<ApplicationResponse> = Vec::new();
+        for app in applications {
             if let Some(application_data) = app.application {
                 if let Ok(app_file) = ApplicationFile::from_str(&application_data) {
-                    all_apps.push(ApplicationResponse {
+                    applications_response.push(ApplicationResponse {
                         file: app_file,
                         issue_reporter_handle: app.issue_reporter_handle,
                         repo: app.repo,
@@ -534,7 +570,7 @@ impl LDNApplication {
                 }
             }
         }
-        Ok(all_apps)
+        applications_response
     }
 
     pub async fn active(