Merge pull request #160 from filecoin-project/feat/adjust-allocator-json

Feat/adjust allocator json

Author: clriesco

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

@@ -37,32 +37,34 @@ pub async fn create_from_json(file: web::Json<ChangedAllocator>) -> actix_web::R
 
     match process_allocator_file(file_name).await {
         Ok(model) => {
-            if model.multisig_address.is_empty() {
+            if model.pathway_addresses.msig.is_empty() {
                 return Ok(HttpResponse::BadRequest().body("Missing or invalid multisig_address"));
             }
             let verifiers_gh_handles = if model.application.verifiers_gh_handles.is_empty() {
                 None
             } else {
                 Some(model.application.verifiers_gh_handles.join(", ")) // Join verifiers in a string if exists
             };
-            
+            let owner = model.owner.clone().unwrap_or_default().to_string();
+            let repo = model.repo.clone().unwrap_or_default().to_string();
+
             let allocator_model = match allocators_db::create_or_update_allocator(
-                model.owner.clone(),
-                model.repo.clone(),
+                owner.clone(),
+                repo.clone(),
                 None,
-                Some(model.multisig_address),      
+                Some(model.pathway_addresses.msig),      
                 verifiers_gh_handles,
                 model.multisig_threshold
             ).await {
                 Ok(allocator_model) => allocator_model,
                 Err(e) => return Ok(HttpResponse::BadRequest().body(e.to_string())),
             };
 
-            match is_allocator_repo_created(&model.owner, &model.repo).await {
+            match is_allocator_repo_created(&owner, &repo).await {
                 Ok(true) => Ok(HttpResponse::Ok().json(allocator_model)),
                 Ok(false) => {
                     //Create allocator repo. If it fails, return http error
-                    match create_allocator_repo(&model.owner, &model.repo).await {
+                    match create_allocator_repo(&owner, &repo).await {
                         Ok(files_list) => {
                             log::info!("Allocator repo created successfully: {:?}", files_list);
                             Ok(HttpResponse::Ok().json(allocator_model))

fplus-lib/src/core/allocator/file.rs

@@ -2,21 +2,24 @@ use serde::{Serialize, Deserialize};
 
 #[derive(Serialize, Deserialize, Debug)]
 pub struct AllocatorModel {
-    #[serde(rename = "slug")]
-    pub repo: String,  
-    #[serde(rename = "organization")]
-    pub owner: String,
-    #[serde(rename = "address")]
-    pub multisig_address: String,
     pub application: Application,
-    #[serde(rename = "multisig_threshold")]
     pub multisig_threshold: Option<i32>,
+    pub pathway_addresses: AllocatorModelPathwayAddresses,
+    pub owner: Option<String>,
+    pub repo: Option<String>,
+}
+
+#[derive(Serialize, Deserialize, Debug)]
+pub struct AllocatorModelPathwayAddresses {
+    pub msig: String,
+    pub signer: Vec<String>,
 }
 
 #[derive(Serialize, Deserialize, Debug)]
 pub struct Application {
     #[serde(rename = "github_handles")]
-    pub verifiers_gh_handles: Vec<String>
+    pub verifiers_gh_handles: Vec<String>,
+    pub allocation_bookkeeping: String,
 }
 
 #[derive(Debug, Serialize, Deserialize)]

fplus-lib/src/core/allocator/mod.rs

@@ -29,7 +29,7 @@ pub async fn process_allocator_file(file_name: &str) -> Result<AllocatorModel, L
     let mut model = content_items_to_allocator_model(content_items).map_err(|e| LDNError::Load(e.to_string()))?;
 
     // Get multisig threshold from the blockchain if multisig address is available
-    if let Ok(blockchain_threshold) = get_multisig_threshold_for_actor(&model.multisig_address).await {
+    if let Ok(blockchain_threshold) = get_multisig_threshold_for_actor(&model.pathway_addresses.msig).await {
         model.multisig_threshold = Some(blockchain_threshold as i32);
     } else {
         log::warn!("Blockchain multisig threshold not found, using default or provided value");
@@ -55,7 +55,16 @@ fn content_items_to_allocator_model(file: ContentItems) -> Result<AllocatorModel
     log::info!("Cleaned content: {:?}", cleaned_content);
 
     match decode_allocator_model(&cleaned_content) {
-        Some(model) => {
+        Some(mut model) => {
+            let owner_repo_parts: Vec<&str> = model.application.allocation_bookkeeping.split('/').collect();
+            if owner_repo_parts.len() < 2 {
+                log::error!("Failed to parse allocator model");
+                return Err(LDNError::Load("Failed to parse allocator model".to_string()));
+            }
+            
+            model.owner = Some(owner_repo_parts[owner_repo_parts.len() - 2].to_string());
+            model.repo = Some(owner_repo_parts[owner_repo_parts.len() - 1].to_string());
+            
             log::info!("Parsed allocator model successfully");
             Ok(model)
         }