Merge pull request #118 from filecoin-project/feat/add-owner-repo-to-endpoints

Added owner and repo

Author: clriesco

fplus-http-server/src/main.rs

@@ -42,8 +42,6 @@ async fn main() -> std::io::Result<()> {
             .service(router::application::validate_application_approval)
             .service(router::blockchain::address_allowance)
             .service(router::blockchain::verified_clients)
-            .service(router::notary::notaries)
-            .service(router::notary::ldn_actors)
             .service(router::govteam::gov_team_members)
             .service(router::allocator::allocators)
             .service(router::allocator::create)

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

@@ -1,7 +1,7 @@
 use actix_web::{get, post, web, HttpResponse, Responder};
 use fplus_lib::core::{
     CompleteGovernanceReviewInfo, CompleteNewApplicationProposalInfo, CreateApplicationInfo,
-    LDNApplication, RefillInfo, ValidationPullRequestData,
+    LDNApplication, RefillInfo, DcReachedInfo, ValidationPullRequestData, GithubQueryParams, ApplicationQueryParams
 };
 
 #[post("/application")]
@@ -17,9 +17,11 @@ pub async fn create(info: web::Json<CreateApplicationInfo>) -> impl Responder {
     }
 }
 
-#[get("/application/{id}")]
-pub async fn single(id: web::Path<String>) -> impl Responder {
-    let app = match LDNApplication::load(id.into_inner()).await {
+#[get("/application")]
+pub async fn single(query: web::Query<ApplicationQueryParams>) -> impl Responder {
+    let ApplicationQueryParams { id, owner, repo } = query.into_inner();
+
+    let app = match LDNApplication::load(id, owner, repo).await {
         Ok(app) => app,
         Err(e) => return HttpResponse::BadRequest().body(e.to_string()),
     };
@@ -35,15 +37,17 @@ pub async fn trigger(
     id: web::Path<String>,
     info: web::Json<CompleteGovernanceReviewInfo>,
 ) -> impl Responder {
-    let ldn_application = match LDNApplication::load(id.into_inner()).await {
+
+    let CompleteGovernanceReviewInfo { actor, owner, repo } = info.into_inner();
+    let ldn_application = match LDNApplication::load(id.into_inner(), owner.clone(), repo.clone()).await {
         Ok(app) => app,
         Err(e) => {
             return HttpResponse::BadRequest().body(e.to_string());
         }
     };
     dbg!(&ldn_application);
     match ldn_application
-        .complete_governance_review(info.into_inner())
+        .complete_governance_review(actor, owner, repo)
         .await
     {
         Ok(app) => HttpResponse::Ok().body(serde_json::to_string_pretty(&app).unwrap()),
@@ -59,14 +63,20 @@ pub async fn propose(
     id: web::Path<String>,
     info: web::Json<CompleteNewApplicationProposalInfo>,
 ) -> impl Responder {
-    let ldn_application = match LDNApplication::load(id.into_inner()).await {
+    let CompleteNewApplicationProposalInfo {
+        signer,
+        request_id, 
+        owner, 
+        repo
+    } = info.into_inner();
+    let ldn_application = match LDNApplication::load(id.into_inner(), owner.clone(), repo.clone()).await {
         Ok(app) => app,
         Err(e) => {
             return HttpResponse::BadRequest().body(e.to_string());
         }
     };
     match ldn_application
-        .complete_new_application_proposal(info.into_inner())
+        .complete_new_application_proposal(signer, request_id, owner, repo)
         .await
     {
         Ok(app) => HttpResponse::Ok().body(serde_json::to_string_pretty(&app).unwrap()),
@@ -81,15 +91,21 @@ pub async fn approve(
     id: web::Path<String>,
     info: web::Json<CompleteNewApplicationProposalInfo>,
 ) -> impl Responder {
-    let ldn_application = match LDNApplication::load(id.into_inner()).await {
+    let CompleteNewApplicationProposalInfo {
+        signer,
+        request_id, 
+        owner, 
+        repo
+    } = info.into_inner();
+    let ldn_application = match LDNApplication::load(id.into_inner(), owner.clone(), repo.clone()).await {
         Ok(app) => app,
         Err(e) => {
             return HttpResponse::BadRequest().body(e.to_string());
         }
     };
     dbg!(&ldn_application);
     match ldn_application
-        .complete_new_application_approval(info.into_inner())
+        .complete_new_application_approval(signer, request_id, owner, repo)
         .await
     {
         Ok(app) => HttpResponse::Ok().body(serde_json::to_string_pretty(&app).unwrap()),
@@ -98,17 +114,19 @@ pub async fn approve(
 }
 
 #[get("/application/active")]
-pub async fn active() -> impl Responder {
-    let apps = match LDNApplication::active(None).await {
+pub async fn active(query: web::Query<GithubQueryParams>) -> impl Responder {
+    let GithubQueryParams { owner, repo } = query.into_inner();
+    let apps = match LDNApplication::active(owner, repo, None).await {
         Ok(app) => app,
         Err(e) => return HttpResponse::BadRequest().body(e.to_string()),
     };
     HttpResponse::Ok().body(serde_json::to_string_pretty(&apps).unwrap())
 }
 
 #[get("/application/merged")]
-pub async fn merged() -> actix_web::Result<impl Responder> {
-    match LDNApplication::merged().await {
+pub async fn merged(query: web::Query<GithubQueryParams>) -> actix_web::Result<impl Responder> {
+    let GithubQueryParams { owner, repo } = query.into_inner();
+    match LDNApplication::merged(owner, repo).await {
         Ok(apps) => Ok(HttpResponse::Ok().body(serde_json::to_string_pretty(&apps).unwrap())),
         Err(e) => {
             return Ok(HttpResponse::InternalServerError().body(e.to_string()));
@@ -125,8 +143,9 @@ pub async fn refill(data: web::Json<RefillInfo>) -> actix_web::Result<impl Respo
 }
 
 #[post("/application/{id}/totaldcreached")]
-pub async fn total_dc_reached(id: web::Path<String>) -> actix_web::Result<impl Responder> {
-    match LDNApplication::total_dc_reached(id.into_inner()).await {
+pub async fn total_dc_reached(id: web::Path<String>, data: web::Json<DcReachedInfo>) -> actix_web::Result<impl Responder> {
+    let DcReachedInfo {owner, repo} = data.into_inner();
+    match LDNApplication::total_dc_reached(id.into_inner(), owner, repo).await {
         Ok(applications) => Ok(HttpResponse::Ok().json(applications)),
         Err(e) => Ok(HttpResponse::BadRequest().body(e.to_string())),
     }
@@ -136,11 +155,11 @@ pub async fn total_dc_reached(id: web::Path<String>) -> actix_web::Result<impl R
 pub async fn validate_application_flow(
     info: web::Json<ValidationPullRequestData>,
 ) -> impl Responder {
-    let pr_number = info.pr_number.trim_matches('"').parse::<u64>();
-
+    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::validate_flow(pr_number, &info.user_handle).await {
+            match LDNApplication::validate_flow(pr_number, &user_handle, owner, repo).await {
                 Ok(result) => HttpResponse::Ok().json(result),
                 Err(e) => HttpResponse::InternalServerError().json(e.to_string()),
             }
@@ -153,11 +172,12 @@ pub async fn validate_application_flow(
 pub async fn validate_application_trigger(
     info: web::Json<ValidationPullRequestData>,
 ) -> impl Responder {
-    let pr_number = info.pr_number.trim_matches('"').parse::<u64>();
+    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::validate_trigger(pr_number, &info.user_handle).await {
+            match LDNApplication::validate_trigger(pr_number, &user_handle, owner, repo).await {
                 Ok(result) => HttpResponse::Ok().json(result),
                 Err(e) => HttpResponse::InternalServerError().json(e.to_string()),
             }
@@ -170,10 +190,11 @@ pub async fn validate_application_trigger(
 pub async fn validate_application_proposal(
     info: web::Json<ValidationPullRequestData>,
 ) -> impl Responder {
-    let pr_number = info.pr_number.trim_matches('"').parse::<u64>();
+    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::validate_proposal(pr_number).await {
+        Ok(pr_number) => match LDNApplication::validate_proposal(pr_number, owner, repo).await {
             Ok(result) => HttpResponse::Ok().json(result),
             Err(e) => HttpResponse::InternalServerError().json(e.to_string()),
         },
@@ -185,10 +206,11 @@ pub async fn validate_application_proposal(
 pub async fn validate_application_approval(
     info: web::Json<ValidationPullRequestData>,
 ) -> impl Responder {
-    let pr_number = info.pr_number.trim_matches('"').parse::<u64>();
+    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::validate_approval(pr_number).await {
+        Ok(pr_number) => match LDNApplication::validate_approval(pr_number, owner, repo).await {
             Ok(result) => HttpResponse::Ok().json(result),
             Err(e) => HttpResponse::InternalServerError().json(e.to_string()),
         },

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

@@ -1,9 +1,11 @@
-use actix_web::{get, HttpResponse, Responder};
-use fplus_lib::core::LDNApplication;
+use actix_web::{get, web, HttpResponse, Responder};
+use fplus_lib::core::{LDNApplication, GithubQueryParams};
 
 #[get("/gov-team-members")]
-pub async fn gov_team_members() -> actix_web::Result<impl Responder> {
-    match LDNApplication::fetch_gov().await {
+pub async fn gov_team_members(query: web::Query<GithubQueryParams>) -> actix_web::Result<impl Responder> {
+    let GithubQueryParams { owner, repo } = query.into_inner();
+
+    match LDNApplication::fetch_verifiers(owner, repo).await {
         Ok(notaries) => {
             Ok(HttpResponse::Ok().json(notaries))
         }

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

@@ -3,7 +3,6 @@ use actix_web::{get, HttpResponse, Responder};
 pub mod application;
 pub mod blockchain;
 pub mod govteam;
-pub mod notary;
 pub mod allocator;
 
 /// Return server health status

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

@@ -29,3 +29,4 @@ tokio = { version = "1.32.0", features = ["rt", "macros"] }
 uuidv4 = "1.0.0"
 rayon = "1.8.0"
 log = "0.4.20"
+fplus-database = { path = "../fplus-database", version = "1.0.19"}

fplus-lib/Cargo.toml

@@ -2,7 +2,7 @@ use std::io::Cursor;
 
 use base64;
 
-use crate::core::application::file::{ApplicationFile, ValidNotaryList, ValidGovTeamList};
+use crate::core::application::file::ApplicationFile;
 
 pub fn decode(i: &str) -> Option<ApplicationFile> {
     let mut binding = Cursor::new(i);
@@ -13,23 +13,3 @@ pub fn decode(i: &str) -> Option<ApplicationFile> {
     };
     Some(app_file)
 }
-
-pub fn decode_notary(i: &str) -> Option<ValidNotaryList> {
-    let mut binding = Cursor::new(i);
-    let decoder = base64::read::DecoderReader::new(&mut binding, base64::STANDARD);
-    let notaries: ValidNotaryList = match serde_json::from_reader(decoder) {
-        Ok(f) => f,
-        Err(_) => return None,
-    };
-    Some(notaries)
-}
-
-pub fn decode_gov_team(i: &str) -> Option<ValidGovTeamList> {
-    let mut binding = Cursor::new(i);
-    let decoder = base64::read::DecoderReader::new(&mut binding, base64::STANDARD);
-    let gov_team: ValidGovTeamList = match serde_json::from_reader(decoder) {
-        Ok(f) => f,
-        Err(_) => return None,
-    };
-    Some(gov_team)
-}

fplus-lib/src/base64.rs

@@ -306,15 +306,15 @@ pub struct Allocation {
 pub struct Notaries(pub Vec<Notary>);
 
 #[derive(Serialize, Deserialize, Debug, Clone)]
-pub struct NotaryInput {
+pub struct VerifierInput {
     pub github_username: String,
     pub signing_address: String,
     pub created_at: String,
     pub message_cid: String,
 }
 
-impl From<NotaryInput> for Notary {
-    fn from(input: NotaryInput) -> Self {
+impl From<VerifierInput> for Notary {
+    fn from(input: VerifierInput) -> Self {
         Self {
             github_username: input.github_username,
             signing_address: input.signing_address,
@@ -345,51 +345,12 @@ pub struct AllocationRequest {
     pub allocation_amount: String,
 }
 
-#[derive(Serialize, Deserialize, Clone, Debug)]
-pub struct NotaryConfig {
-    pub active_signer: bool,
-    pub signing_address: String,
-}
-
-#[derive(Serialize, Deserialize, Debug, Clone)]
-pub struct ValidNotary {
-    pub id: i32,
-    pub organization: String,
-    pub name: String,
-    pub election_round: String,
-    pub status: String,
-    pub use_case: String,
-    pub location: String,
-    pub notary_application_link: String,
-    pub website: String,
-    pub email: Vec<String>,
-    pub fil_slack_id: String,
-    pub github_user: Vec<String>,
-    pub ldn_config: NotaryConfig,
-    pub direct_config: NotaryConfig,
-}
-
-#[derive(Serialize, Deserialize, Debug, Clone)]
-pub struct ValidNotaryList {
-    pub notaries: Vec<ValidNotary>,
-}
-
-impl ValidNotaryList {
-    pub fn is_valid(&self, notary: &str) -> bool {
-        self.notaries
-            .iter()
-            .filter(|n| n.ldn_config.signing_address == notary)
-            .count()
-            > 0
-    }
-}
-
 #[derive(Serialize, Deserialize, Debug, Clone)]
-pub struct ValidGovTeamList {
+pub struct ValidVerifierList {
     pub gov_team: Vec<String>,
 }
 
-impl ValidGovTeamList {
+impl ValidVerifierList {
     pub fn is_valid(&self, member: &str) -> bool {
         self.gov_team.contains(&member.to_string())
     }