Merge pull request #457 from AmbireTech/issue-417-campaign-close-route

elpiel · web-flow · commit 0af06f74c5de · 2021-11-22T13:48:36.000+02:00
Issue 417 campaign close route
diff --git a/sentry/src/db/campaign.rs b/sentry/src/db/campaign.rs
@@ -309,6 +309,19 @@ mod campaign_remaining {
                 .query_async(&mut self.redis.clone())
                 .await
         }
+
+        /// Atomic `getset` [`redis`] operation
+        /// Used to close a [`Campaign`] `POST /campaign/close`
+        pub async fn getset_remaining_to_zero(
+            &self,
+            campaign: CampaignId,
+        ) -> Result<u64, RedisError> {
+            redis::cmd("GETSET")
+                .arg(&Self::get_key(campaign))
+                .arg(0)
+                .query_async(&mut self.redis.clone())
+                .await
+        }
     }
 
     #[cfg(test)]
diff --git a/sentry/src/lib.rs b/sentry/src/lib.rs
@@ -212,23 +212,21 @@ async fn campaigns_router<A: Adapter + 'static>(
         let req = CampaignLoad.call(req, app).await?;
 
         campaign::insert_events::handle_route(req, app).await
-    } else if let (Some(_caps), &Method::POST) =
+    } else if let (Some(caps), &Method::POST) =
         (CLOSE_CAMPAIGN_BY_CAMPAIGN_ID.captures(path), method)
     {
-        // TODO AIP#61: Close campaign:
-        // - only by creator
-        // - sets redis remaining = 0 (`newBudget = totalSpent`, i.e. `newBudget = oldBudget - remaining`)
-
-        // let (is_creator, auth_uid) = match auth {
-        // Some(auth) => (auth.uid == channel.creator, auth.uid.to_string()),
-        // None => (false, Default::default()),
-        // };
-        // Closing a campaign is allowed only by the creator
-        // if has_close_event && is_creator {
-        //     return Ok(());
-        // }
+        let param = RouteParams(vec![caps
+            .get(1)
+            .map_or("".to_string(), |m| m.as_str().to_string())]);
+        req.extensions_mut().insert(param);
 
-        Err(ResponseError::NotFound)
+        req = Chain::new()
+            .chain(AuthRequired)
+            .chain(CampaignLoad)
+            .apply(req, app)
+            .await?;
+
+        campaign::close_campaign(req, app).await
     } else if method == Method::POST && path == "/v5/campaign/list" {
         req = AuthRequired.call(req, app).await?;
 
diff --git a/sentry/src/routes/campaign.rs b/sentry/src/routes/campaign.rs
@@ -21,6 +21,7 @@ use primitives::{
     sentry::{
         campaign::CampaignListQuery,
         campaign_create::{CreateCampaign, ModifyCampaign},
+        SuccessResponse,
     },
     spender::Spendable,
     Address, Campaign, CampaignId, Channel, ChannelId, Deposit, UnifiedNum,
@@ -292,6 +293,49 @@ pub async fn campaign_list<A: Adapter>(
     Ok(success_response(serde_json::to_string(&list_response)?))
 }
 
+/// Can only be called by creator
+/// to close a campaign, just set it's budget to what it's spent so far (so that remaining == 0)
+/// newBudget = totalSpent, i.e. newBudget = oldBudget - remaining
+pub async fn close_campaign<A: Adapter>(
+    req: Request<Body>,
+    app: &Application<A>,
+) -> Result<Response<Body>, ResponseError> {
+    let auth = req
+        .extensions()
+        .get::<Auth>()
+        .expect("Auth should be present");
+
+    let mut campaign = req
+        .extensions()
+        .get::<Campaign>()
+        .expect("We must have a campaign in extensions")
+        .to_owned();
+
+    if auth.uid.to_address() != campaign.creator {
+        Err(ResponseError::Forbidden(
+            "Request not sent by campaign creator".to_string(),
+        ))
+    } else {
+        let old_remaining = app
+            .campaign_remaining
+            .getset_remaining_to_zero(campaign.id)
+            .await
+            .map_err(|e| ResponseError::BadRequest(e.to_string()))?;
+
+        campaign.budget = campaign
+            .budget
+            .checked_sub(&UnifiedNum::from(old_remaining))
+            .ok_or_else(|| {
+                ResponseError::BadRequest("Campaign budget overflows/underflows".to_string())
+            })?;
+        update_campaign(&app.pool, &campaign).await?;
+
+        Ok(success_response(serde_json::to_string(&SuccessResponse {
+            success: true,
+        })?))
+    }
+}
+
 pub mod update_campaign {
     use primitives::Config;
 
@@ -903,13 +947,15 @@ mod test {
         update_campaign::{get_delta_budget, modify_campaign},
         *,
     };
-    use crate::db::redis_pool::TESTS_POOL;
+    use crate::db::{fetch_campaign, redis_pool::TESTS_POOL};
     use crate::test_util::setup_dummy_app;
     use crate::update_campaign::DeltaBudget;
     use adapter::DummyAdapter;
     use hyper::StatusCode;
     use primitives::{
-        adapter::Deposit, util::tests::prep_db::DUMMY_CAMPAIGN, BigNum, ChannelId, ValidatorId,
+        adapter::Deposit,
+        util::tests::prep_db::{DUMMY_CAMPAIGN, IDS},
+        BigNum, ChannelId, ValidatorId,
     };
 
     #[tokio::test]
@@ -1249,4 +1295,81 @@ mod test {
             assert_eq!(delta_budget, Some(DeltaBudget::Decrease(decrease_by)));
         }
     }
+
+    #[tokio::test]
+    async fn campaign_is_closed_properly() {
+        let campaign = DUMMY_CAMPAIGN.clone();
+
+        let app = setup_dummy_app().await;
+
+        insert_channel(&app.pool, campaign.channel)
+            .await
+            .expect("Should insert dummy channel");
+        insert_campaign(&app.pool, &campaign)
+            .await
+            .expect("Should insert dummy campaign");
+
+        // Test if remaining is set to 0
+        {
+            app.campaign_remaining
+                .set_initial(campaign.id, campaign.budget)
+                .await
+                .expect("should set");
+
+            let auth = Auth {
+                era: 0,
+                uid: ValidatorId::from(campaign.creator),
+            };
+
+            let req = Request::builder()
+                .extension(auth)
+                .extension(campaign.clone())
+                .body(Body::empty())
+                .expect("Should build Request");
+
+            close_campaign(req, &app)
+                .await
+                .expect("Should close campaign");
+
+            let closed_campaign = fetch_campaign(app.pool.clone(), &campaign.id)
+                .await
+                .expect("Should fetch campaign")
+                .expect("Campaign should exist");
+
+            // remaining == campaign_budget therefore old_budget - remaining = 0
+            assert_eq!(closed_campaign.budget, UnifiedNum::from_u64(0));
+
+            let remaining = app
+                .campaign_remaining
+                .get_remaining_opt(campaign.id)
+                .await
+                .expect("Should get remaining from redis")
+                .expect("There should be value for the Campaign");
+
+            assert_eq!(remaining, 0);
+        }
+
+        // Test if an error is returned when request is not sent by creator
+        {
+            let auth = Auth {
+                era: 0,
+                uid: IDS["leader"],
+            };
+
+            let req = Request::builder()
+                .extension(auth)
+                .extension(campaign.clone())
+                .body(Body::empty())
+                .expect("Should build Request");
+
+            let res = close_campaign(req, &app)
+                .await
+                .expect_err("Should return error for Bad Campaign");
+
+            assert_eq!(
+                ResponseError::Forbidden("Request not sent by campaign creator".to_string()),
+                res
+            );
+        }
+    }
 }
