Merge remote-tracking branch 'origin/main' into feat/multisig-support

charlykeyko · charlykeyko · commit 8a8533658722 · 2024-03-07T10:31:03.000+01:00
diff --git a/fplus-database/src/database/allocators.rs b/fplus-database/src/database/allocators.rs
@@ -22,6 +22,7 @@ pub async fn get_allocators() ->Result<Vec<AllocatorModel>, sea_orm::DbErr> {
  * @param installation_id: Option<i64> - The installation ID
  * @param multisig_address: Option<String> - The multisig address
  * @param verifiers_gh_handles: Option<String> - The GitHub handles of the verifiers
+ * @param multisig_threshold: Option<i32> - The multisig threshold
  * 
  * # Returns
  * @return Result<AllocatorModel, sea_orm::DbErr> - The result of the operation
@@ -32,16 +33,30 @@ pub async fn update_allocator(
     installation_id: Option<i64>,
     multisig_address: Option<String>,
     verifiers_gh_handles: Option<String>,
+    multisig_threshold: Option<i32>
 ) -> Result<AllocatorModel, sea_orm::DbErr> {
     let conn = get_database_connection().await?;
 
     let existing_allocator = get_allocator(owner, repo).await?;
     if let Some(allocator_model) = existing_allocator {
         let mut allocator_active_model = allocator_model.into_active_model();
 
-        allocator_active_model.installation_id = Set(installation_id);
-        allocator_active_model.multisig_address = Set(multisig_address);
-        allocator_active_model.verifiers_gh_handles = Set(verifiers_gh_handles);
+        //if fields are not None, update them
+        if Some(installation_id) != None {
+            allocator_active_model.installation_id = Set(installation_id);
+        }
+        
+        if Some(multisig_address.clone()) != None {
+            allocator_active_model.multisig_address = Set(multisig_address);
+        }
+
+        if Some(verifiers_gh_handles.clone()) != None {
+            allocator_active_model.verifiers_gh_handles = Set(verifiers_gh_handles);
+        }
+
+        if Some(multisig_threshold) != None {
+            allocator_active_model.multisig_threshold = Set(multisig_threshold);
+        }
 
         let updated_model = allocator_active_model.update(&conn).await?;
 
@@ -108,16 +123,28 @@ pub async fn create_or_update_allocator(
 
         Ok(updated_model)
     } else {
-        let new_allocator = ActiveModel {
+        let mut new_allocator = ActiveModel {
             owner: Set(owner),
             repo: Set(repo),
-            installation_id: Set(installation_id),
-            multisig_address: Set(multisig_address),
-            verifiers_gh_handles: Set(verifiers_gh_handles),
-            multisig_threshold: Set(multisig_threshold),
             ..Default::default()
         };
+
+        if installation_id.is_some() {
+            new_allocator.installation_id = Set(installation_id);
+        }
+
+        if multisig_address.is_some() {
+            new_allocator.multisig_address = Set(multisig_address);
+        }
+
+        if verifiers_gh_handles.is_some() {
+            new_allocator.verifiers_gh_handles = Set(verifiers_gh_handles);
+        }
     
+        if multisig_threshold.is_some() {
+            new_allocator.multisig_threshold = Set(multisig_threshold);
+        }
+
         let conn = get_database_connection().await.expect("Failed to get DB connection");
         new_allocator.insert(&conn).await
     }
diff --git a/fplus-database/src/database/applications.rs b/fplus-database/src/database/applications.rs
@@ -1,17 +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().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)
+   
 }
 
 /**
@@ -24,12 +68,22 @@ 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.clone() {
+        query = query.filter(Column::Owner.contains(owner));
+    }
+    if let Some(repo) = repo {
+        if owner.is_none() {
+            return Err(DbErr::Custom(format!("Owner is required to get merged applications").into()));
+        }
+        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 +98,22 @@ 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.clone() {
+        query = query.filter(Column::Owner.contains(owner));
+    }
+    if let Some(repo) = repo {
+        if owner.is_none() {
+            return Err(DbErr::Custom(format!("Owner is required to get merged applications").into()));
+        }
+        query = query.filter(Column::Repo.contains(repo));
+    }
+    query
+        .order_by(Column::Owner, Order::Asc)
+        .order_by(Column::Repo, Order::Asc)
         .all(&conn)
         .await
 }
diff --git a/fplus-database/src/lib.rs b/fplus-database/src/lib.rs
@@ -169,13 +169,15 @@ mod tests {
         let installation_id = Some(1234);
         let multisig_address = Some("0x0987654321".to_string());
         let verifiers_gh_handles = Some("test_verifier_3, test_verifier_4".to_string());
+        let multisig_threshold = Some(1);
 
         let result = database::allocators::update_allocator(
             &owner,
             &repo,
             installation_id,
             multisig_address,
             verifiers_gh_handles,
+            multisig_threshold
         ).await;
         assert!(result.is_ok());
     }
diff --git a/fplus-http-server/src/router/allocator.rs b/fplus-http-server/src/router/allocator.rs
@@ -83,6 +83,7 @@ pub async fn update(
         info.installation_id,
         info.multisig_address.clone(),
         info.verifiers_gh_handles.clone(),
+        info.multisig_threshold
     ).await {
         Ok(allocator_model) => HttpResponse::Ok().json(allocator_model),
         Err(e) => {
diff --git a/fplus-lib/src/core/mod.rs b/fplus-lib/src/core/mod.rs
@@ -117,6 +117,7 @@ pub struct AllocatorUpdateInfo {
     pub installation_id: Option<i64>,
     pub multisig_address: Option<String>,
     pub verifiers_gh_handles: Option<String>,
+    pub multisig_threshold: Option<i32>,
 }
 
 #[derive(Deserialize)]
@@ -292,61 +293,31 @@ 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 db_apps = database::applications::get_applications().await;
         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
-                    );
+        match db_apps {
+            Ok(apps) => {
+                for app in apps {
+                    let app_file = match ApplicationFile::from_str(&app.application.unwrap()) {
+                        Ok(app) => app,
+                        Err(_) => {
+                            continue;
+                        }
+                    };
+                    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))]);
+            },
         }
 
-        if errors.is_empty() {
-            Ok(all_apps)
-        } else {
-            Err(errors)
-        }
     }
 
     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 {
@@ -368,7 +339,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(_) => {}
                 }
             }
         }
@@ -1014,7 +986,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 {
@@ -1030,7 +1002,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(_) => {},
                 }
             }
         }
@@ -1952,7 +1924,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();
@@ -2009,7 +1981,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();
