Merge pull request #306 from AdExNetwork/supermarket-changes

Supermarket changes

Author: elpiel

primitives/src/ad_slot.rs

@@ -59,7 +59,7 @@ pub struct AdSlot {
     #[serde(default)]
     pub description: Option<String>,
     #[serde(default)]
-    pub webiste: Option<String>,
+    pub website: Option<String>,
     /// user can change it - used for filtering in platform UI
     #[serde(default)]
     pub archived: bool,

primitives/src/sentry.rs

@@ -215,6 +215,40 @@ impl fmt::Display for ChannelReport {
     }
 }
 
+pub mod channel_list {
+    use crate::ValidatorId;
+    use chrono::serde::ts_seconds::deserialize as ts_seconds;
+    use chrono::{DateTime, Utc};
+    use serde::Deserialize;
+
+    #[derive(Debug, Deserialize)]
+    pub struct ChannelListQuery {
+        #[serde(default = "default_page")]
+        pub page: u64,
+        /// filters the list on `valid_until >= valid_until_ge`
+        /// It should be the same timestamp format as the `Channel.valid_until`: **seconds**
+        #[serde(
+            deserialize_with = "ts_seconds",
+            default = "Utc::now",
+            rename = "validUntil"
+        )]
+        pub valid_until_ge: DateTime<Utc>,
+        pub creator: Option<String>,
+        /// filters the channels containing a specific validator if provided
+        pub validator: Option<ValidatorId>,
+    }
+
+    #[derive(Debug, Deserialize)]
+    #[serde(rename_all = "camelCase")]
+    pub struct LastApprovedQuery {
+        pub with_heartbeat: Option<String>,
+    }
+
+    fn default_page() -> u64 {
+        0
+    }
+}
+
 #[cfg(feature = "postgres")]
 mod postgres {
     use super::{

primitives/src/targeting.rs

@@ -30,13 +30,18 @@ impl Input {
                 .map(|ad_view| Value::Bool(ad_view.has_custom_preferences))
                 .ok_or(Error::UnknownVariable),
             "adSlotId" => Ok(Value::String(self.global.ad_slot_id.clone())),
+            "adSlotType" => Ok(Value::String(self.global.ad_slot_type.clone())),
             "adUnitId" => Ok(Value::String(self.global.ad_unit_id.clone())),
-            "adUnitType" => Ok(Value::String(self.global.ad_unit_type.clone())),
             "publisherId" => Ok(Value::String(self.global.publisher_id.clone())),
             "advertiserId" => Ok(Value::String(self.global.advertiser_id.clone())),
-            "country" => Ok(Value::String(self.global.country.clone())),
+            "country" => self
+                .global
+                .country
+                .clone()
+                .map(Value::String)
+                .ok_or(Error::UnknownVariable),
             "eventType" => Ok(Value::String(self.global.event_type.clone())),
-            "campaignId" => Ok(Value::String(self.global.campiagn_id.clone())),
+            "campaignId" => Ok(Value::String(self.global.campaign_id.clone())),
             "campaignTotalSpent" => Ok(Value::String(self.global.campaign_total_spent.clone())),
             "campaignSecondsActive" => {
                 Ok(Value::Number(self.global.campaign_seconds_active.into()))
@@ -51,10 +56,18 @@ impl Input {
                 self.global.publisher_earned_from_campaign.clone(),
             )),
             "secondsSinceEpoch" => Ok(Value::Number(self.global.seconds_since_epoch.into())),
-            "userAgentOS" => Ok(Value::String(self.global.user_agent_os.clone())),
-            "userAgentBrowserFamily" => {
-                Ok(Value::String(self.global.user_agent_browser_family.clone()))
-            }
+            "userAgentOS" => self
+                .global
+                .user_agent_os
+                .clone()
+                .map(Value::String)
+                .ok_or(Error::UnknownVariable),
+            "userAgentBrowserFamily" => self
+                .global
+                .user_agent_browser_family
+                .clone()
+                .map(Value::String)
+                .ok_or(Error::UnknownVariable),
             "adSlot.categories" => self
                 .ad_slot
                 .as_ref()
@@ -70,12 +83,14 @@ impl Input {
             "adSlot.hostname" => self
                 .ad_slot
                 .as_ref()
-                .map(|ad_slot| Value::String(ad_slot.hostname.clone()))
+                .map(|ad_slot| Value::String(ad_slot.hostname.clone().unwrap_or_default()))
                 .ok_or(Error::UnknownVariable),
             "adSlot.alexaRank" => {
+                // @TODO: Decide how to handle Alexa rank values
                 let ad_slot = self.ad_slot.as_ref().ok_or(Error::UnknownVariable)?;
+                let alexa_rank = ad_slot.alexa_rank.ok_or(Error::UnknownVariable)?;
 
-                match serde_json::Number::from_f64(ad_slot.alexa_rank) {
+                match serde_json::Number::from_f64(alexa_rank) {
                     Some(number) => Ok(Value::Number(number)),
                     None => Err(Error::TypeError),
                 }
@@ -95,32 +110,35 @@ pub struct AdView {
 #[derive(Debug, Clone)]
 #[cfg_attr(test, derive(Default))]
 pub struct Global {
+    /// Global scope, accessible everywhere
     pub ad_slot_id: String,
-    pub ad_unit_id: String,
-    pub ad_unit_type: String,
+    pub ad_slot_type: String,
     pub publisher_id: String,
-    pub advertiser_id: String,
-    pub country: String,
+    pub country: Option<String>,
     pub event_type: String,
-    pub campiagn_id: String,
+    pub seconds_since_epoch: u64,
+    pub user_agent_os: Option<String>,
+    pub user_agent_browser_family: Option<String>,
+    /// Global scope, accessible everywhere, campaign-dependant
+    pub ad_unit_id: String,
+    // adUnitCategories
+    pub advertiser_id: String,
+    pub campaign_id: String,
     pub campaign_total_spent: String,
     pub campaign_seconds_active: u64,
     pub campaign_seconds_duration: u64,
     pub campaign_budget: BigNum,
     pub event_min_price: BigNum,
     pub event_max_price: BigNum,
     pub publisher_earned_from_campaign: BigNum,
-    pub seconds_since_epoch: u64,
-    pub user_agent_os: String,
-    pub user_agent_browser_family: String,
 }
 
 #[derive(Debug, Clone)]
 #[cfg_attr(test, derive(Default))]
 pub struct AdSlot {
     pub categories: Vec<String>,
-    pub hostname: String,
-    pub alexa_rank: f64,
+    pub hostname: Option<String>,
+    pub alexa_rank: Option<f64>,
 }
 
 #[derive(Debug)]
@@ -197,6 +215,15 @@ mod test {
             .expect("Should get the global.campaign_budget field");
 
         assert_eq!(Value::BigNum(BigNum::from(50)), global_campaign_budget);
+
+        assert_eq!(
+            Err(Error::UnknownVariable),
+            input.try_get("adSlot.alexaRank")
+        );
+        let mut ad_slot = AdSlot::default();
+        ad_slot.alexa_rank = Some(20.0);
+        input.ad_slot = Some(ad_slot);
+        assert!(input.try_get("adSlot.alexaRank").is_ok());
     }
 
     #[test]

primitives/src/targeting/eval.rs

@@ -628,7 +628,7 @@ mod test {
         input.ad_slot = Some(AdSlot {
             categories: vec!["Bitcoin".to_string(), "Ethereum".to_string()],
             hostname: Default::default(),
-            alexa_rank: 0.0,
+            alexa_rank: Some(0.0),
         });
 
         let mut output = Output {
@@ -655,7 +655,7 @@ mod test {
         input.ad_slot = Some(AdSlot {
             categories: vec!["Advertisement".to_string(), "Programming".to_string()],
             hostname: Default::default(),
-            alexa_rank: 0.0,
+            alexa_rank: Some(0.0),
         });
 
         let result = rules.eval(&input, &mut output).expect("Should eval rules");

sentry/src/db/event_aggregate.rs

@@ -13,7 +13,7 @@ use primitives::BigNum;
 use primitives::{Channel, ChannelId, ValidatorId};
 use std::ops::Add;
 
-pub async fn lastest_approve_state(
+pub async fn latest_approve_state(
     pool: &DbPool,
     channel: &Channel,
 ) -> Result<Option<ApproveStateValidatorMessage>, RunError<bb8_postgres::tokio_postgres::Error>> {
@@ -108,7 +108,7 @@ pub async fn list_event_aggregates(
                 let statement = format!(
                     "
                         WITH aggregates AS (
-                            SELECT 
+                            SELECT
                                 channel_id,
                                 created,
                                 event_type,
@@ -124,7 +124,7 @@ pub async fn list_event_aggregates(
                                         jsonb_build_object(
                                             earner, payout
                                         )
-                                    )    
+                                    )
                                 )
                                 as data
                             FROM event_aggregates WHERE {} GROUP BY channel_id, event_type, created ORDER BY created DESC LIMIT {}

sentry/src/routes/channel.rs

@@ -1,20 +1,20 @@
-use self::channel_list::{ChannelListQuery, LastApprovedQuery};
-use crate::db::event_aggregate::{lastest_approve_state, latest_heartbeats, latest_new_state};
+use crate::db::event_aggregate::{latest_approve_state, latest_heartbeats, latest_new_state};
 use crate::db::{get_channel_by_id, insert_channel, insert_validator_messages, list_channels};
-use crate::success_response;
-use crate::Application;
-use crate::ResponseError;
-use crate::RouteParams;
-use crate::{Auth, Session};
+use crate::{success_response, Application, Auth, ResponseError, RouteParams, Session};
 use bb8::RunError;
 use bb8_postgres::tokio_postgres::error;
 use futures::future::try_join_all;
 use hex::FromHex;
 use hyper::{Body, Request, Response};
-use primitives::adapter::Adapter;
-use primitives::sentry::{Event, LastApproved, LastApprovedResponse, SuccessResponse};
-use primitives::validator::MessageTypes;
-use primitives::{Channel, ChannelId};
+use primitives::{
+    adapter::Adapter,
+    sentry::{
+        channel_list::{ChannelListQuery, LastApprovedQuery},
+        Event, LastApproved, LastApprovedResponse, SuccessResponse,
+    },
+    validator::MessageTypes,
+    Channel, ChannelId,
+};
 use slog::error;
 use std::collections::HashMap;
 
@@ -130,7 +130,7 @@ pub async fn last_approved<A: Adapter>(
         )
         .expect("should build response");
 
-    let approve_state = match lastest_approve_state(&app.pool, &channel).await? {
+    let approve_state = match latest_approve_state(&app.pool, &channel).await? {
         Some(approve_state) => approve_state,
         None => return Ok(default_response),
     };
@@ -139,7 +139,7 @@ pub async fn last_approved<A: Adapter>(
         MessageTypes::ApproveState(approve_state) => approve_state.state_root,
         _ => {
             error!(&app.logger, "{}", "failed to retrieve approved"; "module" => "last_approved");
-            return Err(ResponseError::BadRequest("an error occured".to_string()));
+            return Err(ResponseError::BadRequest("an error occurred".to_string()));
         }
     };
 
@@ -252,37 +252,3 @@ pub async fn create_validator_messages<A: Adapter + 'static>(
         }
     }
 }
-
-mod channel_list {
-    use chrono::serde::ts_seconds::deserialize as ts_seconds;
-    use chrono::{DateTime, Utc};
-    use primitives::ValidatorId;
-    use serde::Deserialize;
-
-    #[derive(Debug, Deserialize)]
-    pub(super) struct ChannelListQuery {
-        #[serde(default = "default_page")]
-        pub page: u64,
-        /// filters the list on `valid_until >= valid_until_ge`
-        /// It should be the same timestamp format as the `Channel.valid_until`: **seconds**
-        #[serde(
-            deserialize_with = "ts_seconds",
-            default = "Utc::now",
-            rename = "validUntil"
-        )]
-        pub valid_until_ge: DateTime<Utc>,
-        pub creator: Option<String>,
-        /// filters the channels containing a specific validator if provided
-        pub validator: Option<ValidatorId>,
-    }
-
-    #[derive(Debug, Deserialize)]
-    #[serde(rename_all = "camelCase")]
-    pub(super) struct LastApprovedQuery {
-        pub with_heartbeat: Option<String>,
-    }
-
-    fn default_page() -> u64 {
-        0
-    }
-}