Optimize get all_applications function from database

Author: charlykeyko

fplus-database/src/database/applications.rs

@@ -1,20 +1,61 @@
-use sea_orm::{entity::*, query::*, DbErr};
+use sea_orm::{entity::*, query::*, DbBackend, DbErr};
 use crate::models::applications::{Column, ActiveModel, Entity as Application, Model as ApplicationModel};
 use crate::get_database_connection;
 use sha1::{Sha1, Digest};
+use chrono::{DateTime, Utc, TimeZone};
 
 /**
  * Get all applications from the database
  * 
  * # Returns
  * @return Result<Vec<ApplicationModel>, sea_orm::DbErr> - The result of the operation
  */
-pub async fn get_applications() ->Result<Vec<ApplicationModel>, sea_orm::DbErr> {
+pub async fn get_applications() -> Result<Vec<ApplicationModel>, sea_orm::DbErr> {
     let conn = get_database_connection().await?;
-    Application::find()
-        .order_by(Column::Owner, Order::Asc)
-        .order_by(Column::Repo, Order::Asc)
-        .all(&conn).await
+
+    //Get all applications from the database. 
+    //Distinct on is not supported in sea_orm yet, so we have to use raw SQL
+    let app_data = JsonValue::find_by_statement(Statement::from_sql_and_values(
+        DbBackend::Postgres,
+        r#"
+            SELECT DISTINCT ON (owner, repo, id) 
+                a.id, 
+                a.owner, 
+                a.repo, 
+                a.pr_number, 
+                a.application, 
+                a.updated_at, 
+                a.sha,
+                a.path
+            FROM 
+                applications a 
+            ORDER BY 
+                a.owner, 
+                a.repo, 
+                a.id, 
+                a.pr_number DESC
+            "#,
+        [],
+    ))
+    .all(&conn)
+    .await?;
+
+    //Iterate over the results and convert them to ApplicationModel
+    let mut applications: Vec<ApplicationModel> = Vec::new();
+    for app in app_data {
+        applications.push(ApplicationModel {
+            id: app.get("id").unwrap().as_str().unwrap().to_string(),
+            owner: app.get("owner").unwrap().as_str().unwrap().to_string(),
+            repo: app.get("repo").unwrap().as_str().unwrap().to_string(),
+            pr_number: app.get("pr_number").unwrap().as_i64().unwrap() as i64,
+            application: Some(app.get("application").unwrap().as_str().unwrap().to_string()),
+            updated_at: Utc.from_utc_datetime(&app.get("updated_at").unwrap().as_str().unwrap().parse::<DateTime<Utc>>().unwrap().naive_utc()),
+            sha: Some(app.get("sha").unwrap().as_str().unwrap().to_string()),
+            path: Some(app.get("path").unwrap().as_str().unwrap().to_string()),
+        });
+    }
+    Ok(applications)
+   
 }
 
 /**

fplus-lib/src/core/mod.rs

@@ -290,44 +290,26 @@ impl LDNApplication {
     }
 
     pub async fn all_applications() -> Result<Vec<(ApplicationFile, String, String)>, Vec<LDNError>> {
-        //TODO: Avoid filtering by allocators. Simply get all active & merged applications from the database.
-        let allocators = match database::allocators::get_allocators().await {
-            Ok(allocs) => allocs,
-            Err(e) => return Err(vec![LDNError::Load(format!("Failed to retrieve allocators: {}", e))]),
-        };        let mut all_apps: Vec<(ApplicationFile, String, String)> = Vec::new();
-        let mut errors: Vec<LDNError> = Vec::new();
-    
-        for allocator in allocators {
-            match Self::active(allocator.owner.clone(), allocator.repo.clone(), None).await {
-                Ok(apps) => {
-                    for app in apps {
-                        all_apps.push((app, allocator.owner.clone(), allocator.repo.clone()));
-                    }
-                },
-                Err(e) => {
-                    errors.push(e);
-                    eprintln!("Failed to process active applications for allocator {}:{}", allocator.repo, allocator.owner);
-                },
-            }
-    
-            match Self::merged(allocator.owner.clone(), allocator.repo.clone()).await {
-                Ok(merged_apps) => {
-                    for (_, app) in merged_apps {
-                        all_apps.push((app, allocator.owner.clone(), allocator.repo.clone()));
-                    }
-                },
-                Err(e) => {
-                    errors.push(e);
-                    eprintln!("Failed to process merged applications for allocator {}:{}", allocator.repo, allocator.owner);
-                },
-            }
-        }
-    
-        if errors.is_empty() {
-            Ok(all_apps)
-        } else {
-            Err(errors)
+        let db_apps = database::applications::get_applications().await;
+        let mut all_apps: Vec<(ApplicationFile, String, String)> = Vec::new();
+        match db_apps {
+            Ok(apps) => {
+                for app in apps {
+                    let app_file = match ApplicationFile::from_str(&app.application.unwrap()) {
+                        Ok(app) => app,
+                        Err(e) => {
+                            return Err(vec![LDNError::Load(format!("Failed to parse application file from DB /// {}", e))]);
+                        }
+                    };
+                    all_apps.push((app_file, app.owner, app.repo));
+                }
+                return Ok(all_apps);
+            },
+            Err(e) => {
+                return Err(vec![LDNError::Load(format!("Failed to retrieve applications from the database /// {}", e))]);
+            },
         }
+
     }