primitive improvements:

- primitives - campaign - Pricing Bounds
- primitives - sentry - Event - ad_unit and ad_slot mandatory
- primitives - targeting - input - use IPFS & EventType

Author: elpiel

adview-manager/src/lib.rs

@@ -211,14 +211,14 @@ pub fn get_unit_html_with_events(
         let event = match event_type {
             "CLICK" => Event::Click {
                 publisher: options.publisher_addr,
-                ad_unit: Some(ad_unit.id),
-                ad_slot: Some(options.market_slot),
+                ad_unit: ad_unit.id,
+                ad_slot: options.market_slot,
                 referrer: Some("document.referrer".to_string()),
             },
             _ => Event::Impression {
                 publisher: options.publisher_addr,
-                ad_unit: Some(ad_unit.id),
-                ad_slot: Some(options.market_slot),
+                ad_unit: ad_unit.id,
+                ad_slot: options.market_slot,
                 referrer: Some("document.referrer".to_string()),
             },
         };

primitives/src/ad_slot.rs

@@ -1,4 +1,4 @@
-use crate::{targeting::Rule, BigNum, ValidatorId, IPFS};
+use crate::{targeting::Rule, ValidatorId, IPFS, Address, UnifiedNum};
 use chrono::{
     serde::{ts_milliseconds, ts_milliseconds_option},
     DateTime, Utc,
@@ -25,9 +25,9 @@ pub struct AdSlot {
     /// see IAB ad unit guidelines and iab_flex_{adUnitName} (see IAB's new ad portfolio and PDF)
     #[serde(rename = "type")]
     pub ad_type: String,
-    // HashMap<DepositAsset, BigNum> for the minimum payment accepted per impression
+    // HashMap<DepositAsset, UnifiedNum> for the minimum payment accepted per impression
     #[serde(default)]
-    pub min_per_impression: Option<HashMap<String, BigNum>>,
+    pub min_per_impression: Option<HashMap<Address, UnifiedNum>>,
     #[serde(default)]
     pub rules: Vec<Rule>,
     /// Valid ipfs hash for Ad Unit object. It will be used as fallback data (optional)

primitives/src/campaign.rs

@@ -1,6 +1,6 @@
 use crate::{
-    targeting::Rules, AdUnit, Address, Channel, EventSubmission, UnifiedNum, Validator,
-    ValidatorDesc, ValidatorId,
+    sentry::EventType, targeting::Rules, AdUnit, Address, Channel, EventSubmission, UnifiedNum,
+    Validator, ValidatorDesc, ValidatorId,
 };
 
 use chrono::{
@@ -175,10 +175,10 @@ pub struct Campaign {
     pub validators: Validators,
     #[serde(default, skip_serializing_if = "Option::is_none")]
     pub title: Option<String>,
-    /// Event pricing bounds
-    #[serde(default, skip_serializing_if = "Option::is_none")]
-    pub pricing_bounds: Option<PricingBounds>,
-    /// EventSubmission object, applies to event submission (POST /channel/:id/events)
+    /// Events pricing bounds
+    #[serde(default, skip_serializing_if = "PricingBounds::is_empty")]
+    pub pricing_bounds: PricingBounds,
+    /// EventSubmission object, applied to event submission
     #[serde(default, skip_serializing_if = "Option::is_none")]
     pub event_submission: Option<EventSubmission>,
     /// An array of AdUnit (optional)
@@ -189,7 +189,6 @@ pub struct Campaign {
     /// A millisecond timestamp of when the campaign was created
     #[serde(with = "ts_milliseconds")]
     pub created: DateTime<Utc>,
-    /// A millisecond timestamp representing the time you want this campaign to become active (optional)
     /// Used by the AdViewManager & Targeting AIP#31
     #[serde(flatten, with = "prefix_active")]
     pub active: Active,
@@ -217,34 +216,36 @@ impl Campaign {
     }
 
     /// Returns the pricing of a given event
-    pub fn pricing(&self, event: &str) -> Option<&Pricing> {
-        self.pricing_bounds
-            .as_ref()
-            .and_then(|bound| bound.get(event))
+    pub fn pricing(&self, event: EventType) -> Option<&Pricing> {
+        self.pricing_bounds.get(&event)
     }
 }
 
 #[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
 pub struct Active {
+    /// Campaign active from in a milliseconds timestamp
+    ///
+    /// The time at which you want this campaign to become active (optional)
     #[serde(
         default,
         skip_serializing_if = "Option::is_none",
         with = "ts_milliseconds_option"
     )]
     pub from: Option<DateTime<Utc>>,
-    //
-    // TODO: AIP#61 Update docs
-    //
-    /// A millisecond timestamp of when the campaign should enter a withdraw period
-    /// (no longer accept any events other than CHANNEL_CLOSE)
-    /// A sane value should be lower than channel.validUntil * 1000 and higher than created
-    /// It's recommended to set this at least one month prior to channel.validUntil * 1000
+    /// Campaign active to in a milliseconds timestamp
+    ///
+    /// The time at which you want this campaign to become inactive (mandatory)
     #[serde(with = "ts_milliseconds")]
     pub to: DateTime<Utc>,
 }
 
 mod pricing {
-    use crate::UnifiedNum;
+    use std::{
+        collections::HashMap,
+        ops::{Deref, DerefMut},
+    };
+
+    use crate::{sentry::EventType, UnifiedNum};
     use serde::{Deserialize, Serialize};
 
     #[derive(Serialize, Deserialize, Debug, Clone, Eq, PartialEq)]
@@ -253,36 +254,33 @@ mod pricing {
         pub max: UnifiedNum,
     }
 
-    #[derive(Serialize, Deserialize, Debug, Clone, Eq, PartialEq)]
-    #[serde(rename_all = "UPPERCASE")]
-    pub struct PricingBounds {
-        #[serde(default, skip_serializing_if = "Option::is_none")]
-        pub impression: Option<Pricing>,
-        #[serde(default, skip_serializing_if = "Option::is_none")]
-        pub click: Option<Pricing>,
-    }
+    #[derive(Default, Debug, PartialEq, Eq, Serialize, Deserialize, Clone)]
+    #[serde(transparent)]
+    pub struct PricingBounds(HashMap<EventType, Pricing>);
 
     impl PricingBounds {
-        pub fn to_vec(&self) -> Vec<(&str, Pricing)> {
-            let mut vec = Vec::new();
+        pub fn is_empty(&self) -> bool {
+            self.0.is_empty()
+        }
+    }
 
-            if let Some(pricing) = self.impression.as_ref() {
-                vec.push(("IMPRESSION", pricing.clone()));
-            }
+    impl FromIterator<(EventType, Pricing)> for PricingBounds {
+        fn from_iter<T: IntoIterator<Item = (EventType, Pricing)>>(iter: T) -> Self {
+            Self(iter.into_iter().collect())
+        }
+    }
 
-            if let Some(pricing) = self.click.as_ref() {
-                vec.push(("CLICK", pricing.clone()))
-            }
+    impl Deref for PricingBounds {
+        type Target = HashMap<EventType, Pricing>;
 
-            vec
+        fn deref(&self) -> &Self::Target {
+            &self.0
         }
+    }
 
-        pub fn get(&self, event_type: &str) -> Option<&Pricing> {
-            match event_type {
-                "IMPRESSION" => self.impression.as_ref(),
-                "CLICK" => self.click.as_ref(),
-                _ => None,
-            }
+    impl DerefMut for PricingBounds {
+        fn deref_mut(&mut self) -> &mut Self::Target {
+            &mut self.0
         }
     }
 }

primitives/src/sentry.rs

@@ -187,15 +187,15 @@ mod event {
         #[serde(rename_all = "camelCase")]
         Impression {
             publisher: Address,
-            ad_unit: Option<IPFS>,
-            ad_slot: Option<IPFS>,
+            ad_unit: IPFS,
+            ad_slot: IPFS,
             referrer: Option<String>,
         },
         #[serde(rename_all = "camelCase")]
         Click {
             publisher: Address,
-            ad_unit: Option<IPFS>,
-            ad_slot: Option<IPFS>,
+            ad_unit: IPFS,
+            ad_slot: IPFS,
             referrer: Option<String>,
         },
     }
@@ -276,8 +276,8 @@ mod event {
 pub struct UpdateAnalytics {
     pub time: DateHour<Utc>,
     pub campaign_id: CampaignId,
-    pub ad_unit: Option<IPFS>,
-    pub ad_slot: Option<IPFS>,
+    pub ad_unit: IPFS,
+    pub ad_slot: IPFS,
     pub ad_slot_type: Option<String>,
     pub advertiser: Address,
     pub publisher: Address,
@@ -294,8 +294,8 @@ pub struct UpdateAnalytics {
 pub struct Analytics {
     pub time: DateHour<Utc>,
     pub campaign_id: CampaignId,
-    pub ad_unit: Option<IPFS>,
-    pub ad_slot: Option<IPFS>,
+    pub ad_unit: IPFS,
+    pub ad_slot: IPFS,
     pub ad_slot_type: Option<String>,
     pub advertiser: Address,
     pub publisher: Address,
@@ -780,8 +780,8 @@ pub mod campaign_create {
         #[serde(default, skip_serializing_if = "Option::is_none")]
         pub title: Option<String>,
         /// Event pricing bounds
-        #[serde(default, skip_serializing_if = "Option::is_none")]
-        pub pricing_bounds: Option<PricingBounds>,
+        #[serde(default, skip_serializing_if = "PricingBounds::is_empty")]
+        pub pricing_bounds: PricingBounds,
         /// EventSubmission object, applies to event submission (POST /channel/:id/events)
         #[serde(default, skip_serializing_if = "Option::is_none")]
         pub event_submission: Option<EventSubmission>,
@@ -874,7 +874,7 @@ pub mod campaign_modify {
                 budget: Some(campaign.budget),
                 validators: Some(campaign.validators),
                 title: campaign.title,
-                pricing_bounds: campaign.pricing_bounds,
+                pricing_bounds: Some(campaign.pricing_bounds),
                 event_submission: campaign.event_submission,
                 ad_units: Some(campaign.ad_units),
                 targeting_rules: Some(campaign.targeting_rules),
@@ -896,7 +896,7 @@ pub mod campaign_modify {
             }
 
             if let Some(new_pricing_bounds) = self.pricing_bounds {
-                campaign.pricing_bounds = Some(new_pricing_bounds);
+                campaign.pricing_bounds = new_pricing_bounds;
             }
 
             if let Some(new_event_submission) = self.event_submission {
@@ -924,7 +924,7 @@ mod postgres {
     };
     use crate::{
         analytics::{AnalyticsQuery, Metric},
-        validator::{messages::Type as MessageType, MessageTypes},
+        validator::{messages::Type as MessageType, MessageTypes}, IPFS,
     };
     use bytes::BytesMut;
     use chrono::{DateTime, Timelike, Utc};
@@ -989,20 +989,8 @@ mod postgres {
                 .get::<_, Option<String>>("country")
                 .filter(|string| !string.is_empty());
 
-            let ad_unit = row.get::<_, Option<String>>("ad_unit").and_then(|string| {
-                if !string.is_empty() {
-                    Some(string.parse().expect("Valid IPFS"))
-                } else {
-                    None
-                }
-            });
-            let ad_slot = row.get::<_, Option<String>>("ad_slot").and_then(|string| {
-                if !string.is_empty() {
-                    Some(string.parse().expect("Valid IPFS"))
-                } else {
-                    None
-                }
-            });
+            let ad_unit = row.get::<_, IPFS>("ad_unit");
+            let ad_slot = row.get::<_, IPFS>("ad_slot");
 
             Self {
                 campaign_id: row.get("campaign_id"),
@@ -1122,8 +1110,8 @@ mod test {
     pub fn test_de_serialize_events() {
         let click = Event::Click {
             publisher: *PUBLISHER,
-            ad_unit: Some(DUMMY_IPFS[0]),
-            ad_slot: Some(DUMMY_IPFS[1]),
+            ad_unit: DUMMY_IPFS[0],
+            ad_slot: DUMMY_IPFS[1],
             referrer: Some("some_referrer".to_string()),
         };
 

primitives/src/targeting.rs

@@ -1,4 +1,4 @@
-use crate::{campaign::Pricing, Campaign, UnifiedNum};
+use crate::{campaign::Pricing, sentry::EventType, Campaign, UnifiedNum};
 
 pub use eval::*;
 use serde_json::Number;
@@ -9,11 +9,10 @@ pub use input::{field::GetField, Input};
 mod eval;
 pub mod input;
 
-pub fn get_pricing_bounds(campaign: &Campaign, event_type: &str) -> Pricing {
+pub fn get_pricing_bounds(campaign: &Campaign, event_type: &EventType) -> Pricing {
     campaign
         .pricing_bounds
-        .as_ref()
-        .and_then(|pricing_bounds| pricing_bounds.get(event_type))
+        .get(event_type)
         .cloned()
         .unwrap_or_else(|| Pricing {
             min: 0.into(),
@@ -59,14 +58,11 @@ impl Output {
 
 impl From<&Campaign> for Output {
     fn from(campaign: &Campaign) -> Self {
-        let price = match &campaign.pricing_bounds {
-            Some(pricing_bounds) => pricing_bounds
-                .to_vec()
-                .into_iter()
-                .map(|(key, price)| (key.to_string(), price.min))
-                .collect(),
-            _ => Default::default(),
-        };
+        let price = campaign
+            .pricing_bounds
+            .iter()
+            .map(|(key, price)| (key.to_string(), price.min))
+            .collect();
 
         Self {
             show: true,
@@ -78,6 +74,8 @@ impl From<&Campaign> for Output {
 
 #[cfg(test)]
 mod test {
+    use crate::sentry::{CLICK, IMPRESSION};
+
     use super::*;
 
     #[test]
@@ -106,20 +104,28 @@ mod test {
     #[test]
     #[allow(clippy::float_cmp)]
     fn test_output_from_channel() {
-        use crate::campaign::{Pricing, PricingBounds};
+        use crate::campaign::Pricing;
         use crate::test_util::DUMMY_CAMPAIGN;
 
         let mut campaign = DUMMY_CAMPAIGN.clone();
-        campaign.pricing_bounds = Some(PricingBounds {
-            impression: Some(Pricing {
-                min: 1_000.into(),
-                max: 2_000.into(),
-            }),
-            click: Some(Pricing {
-                min: 3_000.into(),
-                max: 4_000.into(),
-            }),
-        });
+        campaign.pricing_bounds = vec![
+            (
+                IMPRESSION,
+                Pricing {
+                    min: 1_000.into(),
+                    max: 2_000.into(),
+                },
+            ),
+            (
+                CLICK,
+                Pricing {
+                    min: 3_000.into(),
+                    max: 4_000.into(),
+                },
+            ),
+        ]
+        .into_iter()
+        .collect();
 
         let output = Output::from(&campaign);