Merge pull request #408 from AdExNetwork/v5-modify-submit-campaigns

V5: Authenticated POST route to modify/submit campaigns

Author: elpiel

lib/protocol-eth

@@ -1,7 +1,6 @@
 use crate::{
-    targeting::Rules,
     validator::{ApproveState, Heartbeat, MessageTypes, NewState, Type as MessageType},
-    Address, BalancesMap, BigNum, Channel, ChannelId, ValidatorId, IPFS,
+    Address, BigNum, Channel, ChannelId, ValidatorId, IPFS,
 };
 use chrono::{DateTime, Utc};
 use serde::{Deserialize, Serialize};
@@ -361,6 +360,85 @@ pub mod campaign_create {
             }
         }
     }
+
+    /// This implementation helps with test setup
+    /// **NOTE:** It erases the CampaignId, since the creation of the campaign gives it's CampaignId
+    impl From<Campaign> for CreateCampaign {
+        fn from(campaign: Campaign) -> Self {
+            Self {
+                channel: campaign.channel,
+                creator: campaign.creator,
+                budget: campaign.budget,
+                validators: campaign.validators,
+                title: campaign.title,
+                pricing_bounds: campaign.pricing_bounds,
+                event_submission: campaign.event_submission,
+                ad_units: campaign.ad_units,
+                targeting_rules: campaign.targeting_rules,
+                created: campaign.created,
+                active: campaign.active,
+            }
+        }
+    }
+    
+    // All editable fields stored in one place, used for checking when a budget is changed
+    #[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
+    pub struct ModifyCampaign {
+        pub budget: Option<UnifiedNum>,
+        pub validators: Option<Validators>,
+        pub title: Option<String>,
+        pub pricing_bounds: Option<PricingBounds>,
+        pub event_submission: Option<EventSubmission>,
+        pub ad_units: Option<Vec<AdUnit>>,
+        pub targeting_rules: Option<Rules>,
+    }
+
+    impl ModifyCampaign {
+        pub fn from_campaign(campaign: Campaign) -> Self {
+            ModifyCampaign {
+                budget: Some(campaign.budget),
+                validators: Some(campaign.validators),
+                title: campaign.title,
+                pricing_bounds: campaign.pricing_bounds,
+                event_submission: campaign.event_submission,
+                ad_units: Some(campaign.ad_units),
+                targeting_rules: Some(campaign.targeting_rules),
+            }
+        }
+
+        pub fn apply(self, mut campaign: Campaign) -> Campaign {
+            if let Some(new_budget) = self.budget {
+                campaign.budget = new_budget;
+            }
+
+            if let Some(new_validators) = self.validators {
+                campaign.validators = new_validators;
+            }
+
+            // check if it was passed otherwise not sending a Title will result in clearing of the current one
+            if let Some(new_title) = self.title {
+                campaign.title = Some(new_title);
+            }
+
+            if let Some(new_pricing_bounds) = self.pricing_bounds {
+                campaign.pricing_bounds = Some(new_pricing_bounds);
+            }
+
+            if let Some(new_event_submission) = self.event_submission {
+                campaign.event_submission = Some(new_event_submission);
+            }
+
+            if let Some(new_ad_units) = self.ad_units {
+                campaign.ad_units = new_ad_units;
+            }
+
+            if let Some(new_targeting_rules) = self.targeting_rules {
+                campaign.targeting_rules = new_targeting_rules;
+            }
+
+            campaign
+        }
+    }
 }
 
 #[cfg(feature = "postgres")]

primitives/src/sentry.rs

@@ -68,6 +68,16 @@ impl<S: BalancesState> Balances<S> {
 
         Ok(())
     }
+
+    /// Adds the spender to the Balances with `UnifiedNum::from(0)` if he does not exist
+    pub fn add_spender(&mut self, spender: Address) {
+        self.spenders.entry(spender).or_insert(UnifiedNum::from(0));
+    }
+
+    /// Adds the earner to the Balances with `UnifiedNum::from(0)` if he does not exist
+    pub fn add_earner(&mut self, earner: Address) {
+        self.earners.entry(earner).or_insert(UnifiedNum::from(0));
+    }
 }
 
 #[derive(Debug)]

primitives/src/sentry/accounting.rs

@@ -39,6 +39,12 @@ impl From<&Address> for ValidatorId {
     }
 }
 
+impl From<Address> for ValidatorId {
+    fn from(address: Address) -> Self {
+        Self(address)
+    }
+}
+
 impl From<&[u8; 20]> for ValidatorId {
     fn from(bytes: &[u8; 20]) -> Self {
         Self(Address::from(bytes))

primitives/src/validator.rs

@@ -7,7 +7,7 @@ use lazy_static::lazy_static;
 
 pub mod accounting;
 pub mod analytics;
-mod campaign;
+pub mod campaign;
 mod channel;
 pub mod event_aggregate;
 pub mod spendable;

sentry/src/db.rs

@@ -38,9 +38,7 @@ pub async fn get_accounting_spent(
     Ok(row.get("spent"))
 }
 
-// TODO This is still WIP
-#[allow(dead_code)]
-async fn insert_accounting(
+pub async fn insert_accounting(
     pool: DbPool,
     channel: Channel,
     balances: Balances<CheckedState>,