Merge pull request #411 from AdExNetwork/issue-382-campaign-routes

Issue 382 campaign routes

Author: elpiel

Cargo.lock

@@ -92,8 +92,8 @@ impl Adapter for DummyAdapter {
         Ok(())
     }
 
-    fn whoami(&self) -> &ValidatorId {
-        &self.identity
+    fn whoami(&self) -> ValidatorId {
+        self.identity
     }
 
     fn sign(&self, state_root: &str) -> AdapterResult<String, Self::AdapterError> {

adapter/src/dummy.rs

@@ -149,8 +149,8 @@ impl Adapter for EthereumAdapter {
         Ok(())
     }
 
-    fn whoami(&self) -> &ValidatorId {
-        &self.address
+    fn whoami(&self) -> ValidatorId {
+        self.address
     }
 
     fn sign(&self, state_root: &str) -> AdapterResult<String, Self::AdapterError> {
@@ -263,7 +263,7 @@ impl Adapter for EthereumAdapter {
             address: self.whoami().to_checksum(),
         };
 
-        ewt_sign(&wallet, &self.keystore_pwd, &payload)
+        ewt_sign(wallet, &self.keystore_pwd, &payload)
             .map_err(|err| AdapterError::Adapter(Error::SignMessage(err).into()))
     }
 
@@ -401,8 +401,8 @@ fn hash_message(message: &[u8]) -> [u8; 32] {
     let message_length = message.len();
 
     let mut result = Keccak::new_keccak256();
-    result.update(&format!("{}{}", eth, message_length).as_bytes());
-    result.update(&message);
+    result.update(format!("{}{}", eth, message_length).as_bytes());
+    result.update(message);
 
     let mut res: [u8; 32] = [0; 32];
     result.finalize(&mut res);
@@ -453,7 +453,7 @@ pub fn ewt_sign(
         base64::URL_SAFE_NO_PAD,
     );
     let message = Message::from(hash_message(
-        &format!("{}.{}", header_encoded, payload_encoded).as_bytes(),
+        format!("{}.{}", header_encoded, payload_encoded).as_bytes(),
     ));
     let signature: Signature = signer
         .sign(password, &message)
@@ -475,7 +475,7 @@ pub fn ewt_verify(
     token: &str,
 ) -> Result<VerifyPayload, EwtVerifyError> {
     let message = Message::from(hash_message(
-        &format!("{}.{}", header_encoded, payload_encoded).as_bytes(),
+        format!("{}.{}", header_encoded, payload_encoded).as_bytes(),
     ));
 
     let decoded_signature = base64::decode_config(&token, base64::URL_SAFE_NO_PAD)

adapter/src/ethereum.rs

@@ -172,7 +172,7 @@ fn get_unit_html(
 ) -> String {
     let image_url = normalize_url(&ad_unit.media_url);
 
-    let element_html = if is_video(&ad_unit) {
+    let element_html = if is_video(ad_unit) {
         video_html(on_load, size, &image_url, &ad_unit.media_mime)
     } else {
         image_html(on_load, size, &image_url)

adview-manager/src/lib.rs

@@ -81,7 +81,7 @@ pub trait Adapter: Send + Sync + fmt::Debug + Clone {
     fn unlock(&mut self) -> AdapterResult<(), Self::AdapterError>;
 
     /// Get Adapter whoami
-    fn whoami(&self) -> &ValidatorId;
+    fn whoami(&self) -> ValidatorId;
 
     /// Signs the provided state_root
     fn sign(&self, state_root: &str) -> AdapterResult<String, Self::AdapterError>;

lib/protocol-eth

@@ -243,7 +243,7 @@ impl TryFrom<&str> for BigNum {
     type Error = super::DomainError;
 
     fn try_from(num: &str) -> Result<Self, Self::Error> {
-        let big_uint = BigUint::from_str(&num)
+        let big_uint = BigUint::from_str(num)
             .map_err(|err| super::DomainError::InvalidArgument(err.to_string()))?;
 
         Ok(Self(big_uint))

primitives/src/adapter.rs

@@ -195,7 +195,7 @@ impl Campaign {
         }
     }
 
-    /// Matches the Channel.leader to the Campaign.spec.leader
+    /// Matches the Channel.leader to the Campaign.validators.leader
     /// If they match it returns `Some`, otherwise, it returns `None`
     pub fn leader(&self) -> Option<&'_ ValidatorDesc> {
         self.validators.find(&self.channel.leader)
@@ -318,7 +318,7 @@ pub mod validators {
         }
 
         pub fn iter(&self) -> Iter<'_> {
-            Iter::new(&self)
+            Iter::new(self)
         }
     }
 

primitives/src/big_num.rs

@@ -57,7 +57,7 @@ impl Validator for Campaign {
             return Err(Validation::UnlistedValidator.into());
         }
 
-        if !creator_listed(&self, &config.creators_whitelist) {
+        if !creator_listed(self, &config.creators_whitelist) {
             return Err(Validation::UnlistedCreator.into());
         }
 

primitives/src/campaign.rs

@@ -238,9 +238,9 @@ impl SpecValidators {
 
     pub fn find(&self, validator_id: &ValidatorId) -> Option<SpecValidator<'_>> {
         if &self.leader().id == validator_id {
-            Some(SpecValidator::Leader(&self.leader()))
+            Some(SpecValidator::Leader(self.leader()))
         } else if &self.follower().id == validator_id {
-            Some(SpecValidator::Follower(&self.follower()))
+            Some(SpecValidator::Follower(self.follower()))
         } else {
             None
         }
@@ -257,7 +257,7 @@ impl SpecValidators {
     }
 
     pub fn iter(&self) -> Iter<'_> {
-        Iter::new(&self)
+        Iter::new(self)
     }
 }
 

primitives/src/campaign_validator.rs

@@ -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};
@@ -127,19 +126,6 @@ pub enum Event {
         ad_slot: Option<IPFS>,
         referrer: Option<String>,
     },
-    /// only the creator can send this event
-    #[serde(rename_all = "camelCase")]
-    UpdateTargeting { targeting_rules: Rules },
-    /// Closes the `Campaign`
-    /// only the creator can send this event
-    #[serde(rename_all = "camelCase")]
-    Close,
-    /// TODO: AIP#61 Check and explain who can send this event as well as when it can be received
-    /// A map of earners which gets merged in the `spender::Aggregate`
-    /// NOTE: Does **not** contain any fees!
-    /// This even can be used to pay to yourself, but this is irrelevant as it's your funds you are paying yourself.
-    #[serde(rename_all = "camelCase")]
-    Pay { payout: BalancesMap },
 }
 
 impl Event {
@@ -161,9 +147,6 @@ impl AsRef<str> for Event {
         match *self {
             Event::Impression { .. } => "IMPRESSION",
             Event::Click { .. } => "CLICK",
-            Event::UpdateTargeting { .. } => "UPDATE_TARGETING",
-            Event::Close => "CLOSE",
-            Event::Pay { .. } => "PAY",
         }
     }
 }
@@ -377,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/channel.rs

@@ -68,11 +68,27 @@ impl<S: BalancesState> Balances<S> {
 
         Ok(())
     }
+
+    /// Adds the spender to the Balances with `0` if he does not exist
+    pub fn add_spender(&mut self, spender: Address) {
+        self.spenders
+            .entry(spender)
+            .or_insert_with(UnifiedNum::default);
+    }
+
+    /// Adds the earner to the Balances with `0` if he does not exist
+    pub fn add_earner(&mut self, earner: Address) {
+        self.earners
+            .entry(earner)
+            .or_insert_with(UnifiedNum::default);
+    }
 }
 
-#[derive(Debug)]
+#[derive(Debug, Error)]
 pub enum OverflowError {
+    #[error("Spender {0} amount overflowed")]
     Spender(Address),
+    #[error("Earner {0} amount overflowed")]
     Earner(Address),
 }
 
@@ -196,30 +212,3 @@ mod de {
         }
     }
 }
-
-#[cfg(feature = "postgres")]
-mod postgres {
-    use super::*;
-    use postgres_types::Json;
-    use tokio_postgres::Row;
-
-    impl TryFrom<&Row> for Accounting<CheckedState> {
-        type Error = Error;
-
-        fn try_from(row: &Row) -> Result<Self, Self::Error> {
-            let balances = Balances::<UncheckedState> {
-                earners: row.get::<_, Json<_>>("earners").0,
-                spenders: row.get::<_, Json<_>>("spenders").0,
-                state: PhantomData::default(),
-            }
-            .check()?;
-
-            Ok(Self {
-                channel: row.get("channel"),
-                balances,
-                updated: row.get("updated"),
-                created: row.get("created"),
-            })
-        }
-    }
-}

primitives/src/sentry.rs

@@ -25,5 +25,5 @@ pub fn past_datetime(from: Option<&DateTime<Utc>>) -> DateTime<Utc> {
 
     let from = from.unwrap_or(&default_from);
 
-    datetime_between(&from, Some(&to))
+    datetime_between(from, Some(&to))
 }

primitives/src/sentry/accounting.rs

@@ -27,7 +27,7 @@ impl ValidatorId {
     }
 
     pub fn inner(&self) -> &[u8; 20] {
-        &self.0.as_bytes()
+        self.0.as_bytes()
     }
 }
 
@@ -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))
@@ -47,7 +53,7 @@ impl From<&[u8; 20]> for ValidatorId {
 
 impl AsRef<[u8]> for ValidatorId {
     fn as_ref(&self) -> &[u8] {
-        &self.0.as_ref()
+        self.0.as_ref()
     }
 }