Get SHA from github in merge

Author: charlykeyko

fplus-database/src/database/applications.rs

@@ -123,30 +123,41 @@ pub async fn get_application_by_pr_number(owner: String, repo: String, pr_number
  * # Returns
  * @return Result<ApplicationModel, sea_orm::DbErr> - The result of the operation
  */
-pub async fn merge_application_by_pr_number(owner: String, repo: String, pr_number: u64) -> Result<ApplicationModel, sea_orm::DbErr> {
+pub async fn merge_application_by_pr_number(owner: String, repo: String, pr_number: u64, sha: String) -> Result<ApplicationModel, sea_orm::DbErr> {
     let conn = get_database_connection().await?;
-    let existing_application = get_application_by_pr_number(owner.clone(), repo.clone(), pr_number).await?;
-    let mut active_application = existing_application.into_active_model();
-    
-    let application_id = if let Some(id) = active_application.id.take() {
-      id
-  } else {
-      return Err(DbErr::Custom("Application ID is not set".into()));
-  };
-
-    // Delete the application with pr_number 0
-    Application::delete_many()
-      .filter(Column::Id.eq(application_id))
-      .filter(Column::Owner.contains(owner))
-      .filter(Column::Repo.contains(repo))
-      .filter(Column::PrNumber.eq(0))
-      .exec(&conn)
-      .await?;
-
-    // Update the application and set pr_number to 0
-    active_application.pr_number = Set(0);
-    let updated_application = active_application.update(&conn).await?;
-    Ok(updated_application)
+    let pr_application = get_application_by_pr_number(owner.clone(), repo.clone(), pr_number).await?;
+    let mut exists_merged = true;
+    let merged_application = match get_application_by_pr_number(owner.clone(), repo.clone(), 0).await {
+        Ok(application) => application.into_active_model(),
+        Err(_) => {
+            exists_merged = false;
+            ActiveModel {
+                id: Set(pr_application.id.clone()),
+                owner: Set(owner),
+                repo: Set(repo),
+                pr_number: Set(0),
+                application: Set(pr_application.application.clone()),
+                sha: Set(Some(sha)),
+                path: Set(pr_application.path.clone()),
+                ..Default::default()
+            }
+        }
+    };
+
+    pr_application.delete(&conn).await?;
+    if exists_merged {
+        let result = merged_application.update(&conn).await;
+        match result {
+            Ok(application) => Ok(application),
+            Err(e) => Err(sea_orm::DbErr::Custom(format!("Failed to merge application: {}", e))),
+        }
+    } else {
+        let result = merged_application.insert(&conn).await;
+        match result {
+            Ok(application) => Ok(application),
+            Err(e) => Err(sea_orm::DbErr::Custom(format!("Failed to merge application: {}", e))),
+        }
+    }
 }
 
 /**

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-http-server/src/main.rs

@@ -40,6 +40,7 @@ async fn main() -> std::io::Result<()> {
             .service(router::application::validate_application_trigger)
             .service(router::application::validate_application_proposal)
             .service(router::application::validate_application_approval)
+            .service(router::application::validate_application_merge)
             .service(router::application::cache_renewal)
             .service(router::blockchain::address_allowance)
             .service(router::blockchain::verified_clients)

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

@@ -231,15 +231,15 @@ pub async fn validate_application_approval(
     }
 }
 
-#[post("application/merge")]
-pub async fn merge_application(
+#[post("application/merge/validate")]
+pub async fn validate_application_merge(
     info: web::Json<ValidationPullRequestData>,
 ) -> impl Responder {
     let ValidationPullRequestData { pr_number, user_handle: _, owner, repo } = info.into_inner();
     let pr_number = pr_number.trim_matches('"').parse::<u64>();
 
     match pr_number {
-        Ok(pr_number) => match LDNApplication::merge_application(pr_number, owner, repo).await {
+        Ok(pr_number) => match LDNApplication::validate_merge_application(pr_number, owner, repo).await {
             Ok(result) => HttpResponse::Ok().json(result),
             Err(e) => HttpResponse::InternalServerError().json(e.to_string()),
         },

fplus-lib/src/core/mod.rs

@@ -290,6 +290,7 @@ 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))]),
@@ -996,7 +997,57 @@ impl LDNApplication {
         Err(LDNError::Load("Failed to get application file".to_string()))
     }
 
-    pub async fn merge_application(pr_number: u64, owner: String, repo: String) -> Result<bool, LDNError> {
+    pub async fn validate_merge_application(pr_number: u64, owner: String, repo: String) -> Result<bool, LDNError> {
+        log::info!("Starting validate_merge_application:");
+        log::info!(
+            "- Validating merge for PR number {}",
+            pr_number,
+        );
+
+        let application = match LDNApplication::single_active(pr_number, owner.clone(), repo.clone()).await {
+            Ok(app) => {
+                log::info!("- Got application");
+                app
+            }
+            Err(err) => {
+                log::error!("- Failed to get application. Reason: {}", err);
+                return Err(LDNError::Load(format!(
+                    "Failed to get application. Reason: {}",
+                    err
+                )));
+            }
+        };
+
+        // conditions for automerge:
+        // 1. Application is in Granted state
+        // 2. Application has Validated by and Validated at fields set
+        // 3. Application doesn't have an active request
+        if application.lifecycle.get_state() == AppState::Granted {
+            if application.lifecycle.validated_by.is_empty() {
+                log::warn!("- Application has not been validated");
+                return Ok(false);
+            }
+            if application.lifecycle.validated_at.is_empty() {
+                log::warn!("- Application has not been validated at");
+                return Ok(false);
+            }
+            let active_request = application.allocation.active();
+            if active_request.is_some() {
+                log::warn!("- Application has an active request");
+                return Ok(false);
+            }
+            log::info!("- Application is in a valid state!");
+
+            Self::merge_application(pr_number, owner, repo, application.id).await?;
+            return Ok(true);
+        }
+
+        log::warn!("- Application is not in a valid state");
+        return Ok(false);
+        
+    }
+
+    pub async fn merge_application(pr_number: u64, owner: String, repo: String, application_id: String) -> Result<bool, LDNError> {
         let gh = GithubWrapper::new(owner.clone(), repo.clone());
 
         gh.merge_pull_request(pr_number).await.map_err(|e| {
@@ -1006,7 +1057,23 @@ impl LDNApplication {
             ))
         })?;
 
-        database::applications::merge_application_by_pr_number(owner, repo, pr_number).await.map_err(|e| {
+        //Get file SHA with get_file function
+
+        let file_name = LDNPullRequest::application_path(&application_id);
+        let branch_name = "main";
+        let file_sha = match GithubWrapper::new(owner.clone(), repo.clone())
+            .get_file(&file_name, &branch_name).await {
+                Ok(file) => file.items.get(0).unwrap().sha.clone(),
+                Err(e) => {
+                    log::error!("- Failed to get file content. Reason: {}", e);
+                    return Err(LDNError::Load(format!(
+                        "Failed to get file content. Reason: {}",
+                        e
+                    )));
+                }
+        };
+
+        database::applications::merge_application_by_pr_number(owner, repo, pr_number, file_sha).await.map_err(|e| {
             LDNError::Load(format!(
                 "Failed to update application in database. Reason: {}",
                 e