fix errors in all_applications

Author: charlykeyko

fplus-database/src/database/applications.rs

@@ -11,7 +11,10 @@ use sha1::{Sha1, Digest};
  */
 pub async fn get_applications() ->Result<Vec<ApplicationModel>, sea_orm::DbErr> {
     let conn = get_database_connection().await?;
-    Application::find().all(&conn).await
+    Application::find()
+        .order_by(Column::Owner, Order::Asc)
+        .order_by(Column::Repo, Order::Asc)
+        .all(&conn).await
 }
 
 /**
@@ -24,12 +27,19 @@ pub async fn get_applications() ->Result<Vec<ApplicationModel>, sea_orm::DbErr>
  * # Returns
  * @return Result<Vec<ApplicationModel>, sea_orm::DbErr> - The result of the operation
  */
-pub async fn get_merged_applications(owner: String, repo: String) -> Result<Vec<ApplicationModel>, sea_orm::DbErr> {
+pub async fn get_merged_applications(owner: Option<String>, repo: Option<String>) -> Result<Vec<ApplicationModel>, sea_orm::DbErr> {
     let conn = get_database_connection().await?;
-    Application::find()
-        .filter(Column::Owner.contains(owner))
-        .filter(Column::Repo.contains(repo))
-        .filter(Column::PrNumber.eq(0))
+    let mut query = Application::find()
+        .filter(Column::PrNumber.eq(0));
+    if let Some(owner) = owner {
+        query = query.filter(Column::Owner.contains(owner));
+    }
+    if let Some(repo) = repo {
+        query = query.filter(Column::Repo.contains(repo));
+    }
+    query
+        .order_by(Column::Owner, Order::Asc)
+        .order_by(Column::Repo, Order::Asc)
         .all(&conn)
         .await
 }
@@ -44,12 +54,19 @@ pub async fn get_merged_applications(owner: String, repo: String) -> Result<Vec<
  * # Returns
  * @return Result<Vec<ApplicationModel>, sea_orm::DbErr> - The result of the operation
  */
-pub async fn get_active_applications(owner: String, repo: String) -> Result<Vec<ApplicationModel>, sea_orm::DbErr> {
+pub async fn get_active_applications(owner: Option<String>, repo: Option<String>) -> Result<Vec<ApplicationModel>, sea_orm::DbErr> {
     let conn = get_database_connection().await?;
-    Application::find()
-        .filter(Column::Owner.contains(owner))
-        .filter(Column::Repo.contains(repo))
-        .filter(Column::PrNumber.ne(0))
+    let mut query = Application::find()
+        .filter(Column::PrNumber.ne(0));
+    if let Some(owner) = owner {
+        query = query.filter(Column::Owner.contains(owner));
+    }
+    if let Some(repo) = repo {
+        query = query.filter(Column::Repo.contains(repo));
+    }
+    query
+        .order_by(Column::Owner, Order::Asc)
+        .order_by(Column::Repo, Order::Asc)
         .all(&conn)
         .await
 }

fplus-database/src/lib.rs

@@ -232,4 +232,27 @@ mod tests {
 
     }
 
+    /**
+     * Test the create_application function
+     *
+     * # Returns
+     * @return () - The result of the test
+     */
+    #[tokio::test]
+    #[serial]
+    async fn test_create_application() {
+        setup_test_environment().await;
+
+        let id = "test_id".to_string();
+        let owner = "keyko-io".to_string();
+        let repo = "great-test-library".to_string();
+        let pr_number = 14;
+        let app_file = "test_app_file".to_string();
+        let sha = "test_sha".to_string();
+        let path = "test_path".to_string();
+
+        let result = database::applications::create_application(id, owner, repo, pr_number, app_file, sha, path).await;
+        assert!(result.is_ok());
+    }
+
 }

fplus-lib/src/core/mod.rs

@@ -333,7 +333,7 @@ impl LDNApplication {
 
     pub async fn active(owner: String, repo: String, filter: Option<String>) -> Result<Vec<ApplicationFile>, LDNError> {
         // Get all active applications from the database.
-        let active_apps_result = database::applications::get_active_applications(owner, repo).await;
+        let active_apps_result = database::applications::get_active_applications(Some(owner), Some(repo)).await;
 
         // Handle errors in getting active applications.
         let active_apps = match active_apps_result {
@@ -355,7 +355,8 @@ impl LDNApplication {
             if let Some(app_json) = app_model.application {
                 match from_str::<ApplicationFile>(&app_json) {
                     Ok(app) => apps.push(app),
-                    Err(e) => return Err(LDNError::Load(format!("Failed to parse application file: {}", e))),
+                    //if error, don't push into apps
+                    Err(_) => {}
                 }
             }
         }
@@ -934,7 +935,7 @@ impl LDNApplication {
 
     pub async fn merged(owner: String, repo: String) -> Result<Vec<(ApplicationGithubInfo, ApplicationFile)>, LDNError> {
         // Retrieve all applications in the main branch from the database.
-        let merged_apps_result = database::applications::get_merged_applications(owner.clone(), repo.clone()).await;
+        let merged_apps_result = database::applications::get_merged_applications(Some(owner.clone()), Some(repo.clone())).await;
 
         // Handle errors in getting applications from the main branch.
         let merged_app_models = match merged_apps_result {
@@ -950,7 +951,7 @@ impl LDNApplication {
             if let Some(app_json) = app_model.application {
                 match from_str::<ApplicationFile>(&app_json) {
                     Ok(app) => merged_apps.push((ApplicationGithubInfo {sha: app_model.sha.unwrap(), path: app_model.path.unwrap()}, app)),
-                    Err(e) => return Err(LDNError::Load(format!("Failed to parse application file: {}", e))),
+                    Err(_) => {},
                 }
             }
         }
@@ -1807,7 +1808,7 @@ Your Datacap Allocation Request has been {} by the Notary
 
     pub async fn cache_renewal_active(owner: String, repo: String) -> Result<(), LDNError> {
         let active_from_gh: Vec<ApplicationFileWithDate> = LDNApplication::active_apps_with_last_update(owner.clone(), repo.clone(), None).await?;
-        let active_from_db: Vec<ApplicationModel> = database::applications::get_active_applications(owner.clone(), repo.clone()).await.unwrap();
+        let active_from_db: Vec<ApplicationModel> = database::applications::get_active_applications(Some(owner.clone()), Some(repo.clone())).await.unwrap();
 
         let mut db_apps_set: HashSet<String> = HashSet::new();
         let mut processed_gh_apps: HashSet<String> = HashSet::new();
@@ -1864,7 +1865,7 @@ Your Datacap Allocation Request has been {} by the Notary
 
     pub async fn cache_renewal_merged(owner: String, repo: String) -> Result<(), LDNError> {
         let merged_from_gh: Vec<ApplicationFileWithDate> = LDNApplication::merged_apps_with_last_update(owner.clone(), repo.clone(), None).await?;
-        let merged_from_db: Vec<ApplicationModel> = database::applications::get_merged_applications(owner.clone(), repo.clone()).await.unwrap();
+        let merged_from_db: Vec<ApplicationModel> = database::applications::get_merged_applications(Some(owner.clone()), Some(repo.clone())).await.unwrap();
 
         let mut db_apps_set: HashSet<String> = HashSet::new();
         let mut processed_gh_apps: HashSet<String> = HashSet::new();