retrieve all applications

Author: charlykeyko

fplus-http-server/src/main.rs

@@ -32,6 +32,7 @@ async fn main() -> std::io::Result<()> {
             .service(router::application::approve)
             .service(router::application::merged)
             .service(router::application::active)
+            .service(router::application::all_applications)
             .service(router::application::refill)
             .service(router::application::total_dc_reached)
             .service(router::application::single)

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

@@ -113,6 +113,19 @@ pub async fn approve(
     }
 }
 
+#[get("/applications")]
+pub async fn all_applications() -> impl Responder {
+    match LDNApplication::all_applications().await {
+        Ok(apps) => {
+            match serde_json::to_string_pretty(&apps) {
+                Ok(json) => HttpResponse::Ok().content_type("application/json").body(json),
+                Err(e) => HttpResponse::InternalServerError().body(format!("Failed to serialize applications: {}", e)),
+            }
+        },
+        Err(e) => HttpResponse::BadRequest().body(e.to_string()),
+    }
+}
+
 #[get("/application/active")]
 pub async fn active(query: web::Query<GithubQueryParams>) -> impl Responder {
     let GithubQueryParams { owner, repo } = query.into_inner();

fplus-lib/src/core/mod.rs

@@ -238,6 +238,30 @@ impl LDNApplication {
         });
     }
 
+    pub async fn all_applications() -> Result<Vec<ApplicationFile>, LDNError> {
+        let allocators = database::get_allocators().await.map_err(|e| LDNError::Load(format!("Failed to retrieve allocators /// {}", e)))?;
+    
+        let mut all_apps: Vec<ApplicationFile> = Vec::new();
+        for allocator in allocators {
+            // Process active applications
+            if let Ok(apps) = Self::active(allocator.owner.clone(), allocator.repo.clone(), None).await {
+                all_apps.extend(apps);
+            } else {
+                eprintln!("Failed to process active applications for allocator {}:{}", allocator.repo, allocator.owner);
+            }
+    
+            // Process merged applications
+            if let Ok(merged_apps) = Self::merged(allocator.owner.clone(), allocator.repo.clone()).await {
+                // Assuming you only need ApplicationFile from the tuple (Content, ApplicationFile)
+                all_apps.extend(merged_apps.into_iter().map(|(_, app_file)| app_file));
+            } else {
+                eprintln!("Failed to process merged applications for allocator {}:{}", allocator.repo, allocator.owner);
+            }
+        }
+    
+        Ok(all_apps)
+    }
+
     pub async fn active(owner: String, repo: String, filter: Option<String>) -> Result<Vec<ApplicationFile>, LDNError> {
         let gh: GithubWrapper = GithubWrapper::new(owner.clone(), repo.clone());
         let mut apps: Vec<ApplicationFile> = Vec::new();