Merge branch 'dev' into issue-9-get-event-aggregates

Author: elpiel

Cargo.lock

@@ -145,7 +145,7 @@ impl Adapter for EthereumAdapter {
                 ));
             }
 
-            let contract_address = Address::from_slice(&self.config.ethereum_core_address);
+            let contract_address: Address = self.config.ethereum_core_address.into();
 
             let (_eloop, transport) = web3::transports::Http::new(&self.config.ethereum_network)
                 .map_err(|_| map_error("failed to init http transport"))?;
@@ -209,7 +209,7 @@ impl Adapter for EthereumAdapter {
 
             let sess = match &verified.payload.identity {
                 Some(identity) => {
-                    let contract_address = Address::from_slice(identity);
+                    let contract_address: Address = identity.into();
                     let (_eloop, transport) =
                         web3::transports::Http::new(&self.config.ethereum_network)
                             .map_err(|_| map_error("failed to init http transport"))?;

adapter/src/ethereum.rs

@@ -87,12 +87,12 @@ impl TryFrom<&Channel> for EthereumChannel {
         hash.input(spec);
         let spec_hash: [u8; 32] = hash.result().into();
 
-        let validators: Vec<ValidatorId> = channel
+        let validators = channel
             .spec
             .validators
-            .into_iter()
-            .map(|v| v.id.clone())
-            .collect();
+            .iter()
+            .map(|v| &v.id)
+            .collect::<Vec<_>>();
 
         let creator = channel.creator.inner();
         let deposit_asset = <[u8; 20]>::from_hex(&channel.deposit_asset[2..])
@@ -103,7 +103,7 @@ impl TryFrom<&Channel> for EthereumChannel {
             &deposit_asset,
             &channel.deposit_amount.to_string(),
             channel.valid_until,
-            &validators.as_slice(),
+            &validators,
             &spec_hash,
         )
     }
@@ -115,7 +115,7 @@ impl EthereumChannel {
         token_addr: &[u8; 20],
         token_amount: &str, // big num string
         valid_until: DateTime<Utc>,
-        validators: &[ValidatorId],
+        validators: &[&ValidatorId],
         spec: &[u8; 32],
     ) -> Result<Self, ChannelError> {
         if BigNum::try_from(token_amount).is_err() {
@@ -171,7 +171,7 @@ impl EthereumChannel {
     }
 
     pub fn hash_hex(&self, contract_addr: &[u8; 20]) -> Result<String, Box<dyn Error>> {
-        let result = self.hash(&contract_addr)?;
+        let result = self.hash(contract_addr)?;
         Ok(format!("0x{}", hex::encode(result)))
     }
 

adapter/src/lib.rs

@@ -234,7 +234,7 @@ pub fn get_html(
         }],
     };
 
-    let on_load: String = validators.into_iter().map(|validator| {
+    let on_load: String = validators.iter().map(|validator| {
         let fetch_opts = "{ method: 'POST', headers: { 'content-type': 'application/json' }, body: this.dataset.eventBody }";
         let fetch_url = format!("{}/channel/{}/events", validator.url, channel_id);
 

adview-manager/src/lib.rs

@@ -37,7 +37,7 @@ rand = "^0.6"
 # postgres feature
 postgres-types = { version = "0.1.0-alpha.2", optional = true }
 bytes = { version = "0.5", optional = true }
-tokio-postgres = { version = "0.5.0-alpha.2", optional = true, features = ["with-chrono-0_4", "with-serde_json-1"] }
+tokio-postgres = { version = "0.5.1", optional = true, features = ["with-chrono-0_4", "with-serde_json-1"] }
 # Futures
 futures = "0.3.1"
 # Other

primitives/Cargo.toml

@@ -0,0 +1,85 @@
+use crate::DomainError;
+use serde::{Deserialize, Serialize};
+
+pub const ANALYTICS_QUERY_LIMIT: u32 = 200;
+
+#[derive(Debug, Serialize, Deserialize)]
+pub struct AnalyticsResponse {
+    time: u32,
+    value: String,
+}
+
+#[cfg(feature = "postgres")]
+pub mod postgres {
+    use super::AnalyticsResponse;
+    use tokio_postgres::Row;
+
+    impl From<&Row> for AnalyticsResponse {
+        fn from(row: &Row) -> Self {
+            Self {
+                time: row.get("time"),
+                value: row.get("value"),
+            }
+        }
+    }
+}
+
+#[derive(Debug, Deserialize)]
+pub struct AnalyticsQuery {
+    #[serde(default = "default_limit")]
+    pub limit: u32,
+    #[serde(default = "default_event_type")]
+    pub event_type: String,
+    #[serde(default = "default_metric")]
+    pub metric: String,
+    #[serde(default = "default_timeframe")]
+    pub timeframe: String,
+}
+
+impl AnalyticsQuery {
+    pub fn is_valid(&self) -> Result<(), DomainError> {
+        let valid_event_types = ["IMPRESSION", "CLICK"];
+        let valid_metric = ["eventPayouts", "eventCounts"];
+        let valid_timeframe = ["year", "month", "week", "day", "hour"];
+
+        if !valid_event_types.contains(&self.event_type.as_str()) {
+            Err(DomainError::InvalidArgument(format!(
+                "invalid event_type, possible values are: {}",
+                valid_event_types.join(" ,")
+            )))
+        } else if !valid_metric.contains(&self.metric.as_str()) {
+            Err(DomainError::InvalidArgument(format!(
+                "invalid metric, possible values are: {}",
+                valid_metric.join(" ,")
+            )))
+        } else if !valid_timeframe.contains(&self.timeframe.as_str()) {
+            Err(DomainError::InvalidArgument(format!(
+                "invalid timeframe, possible values are: {}",
+                valid_timeframe.join(" ,")
+            )))
+        } else if self.limit > ANALYTICS_QUERY_LIMIT {
+            Err(DomainError::InvalidArgument(format!(
+                "invalid limit {}, maximum value 200",
+                self.limit
+            )))
+        } else {
+            Ok(())
+        }
+    }
+}
+
+fn default_limit() -> u32 {
+    100
+}
+
+fn default_event_type() -> String {
+    "IMPRESSION".into()
+}
+
+fn default_metric() -> String {
+    "eventCounts".into()
+}
+
+fn default_timeframe() -> String {
+    "hour".into()
+}

primitives/src/analytics.rs

@@ -148,6 +148,10 @@ impl SpecValidators {
             SpecValidator::None
         }
     }
+
+    pub fn iter(&self) -> Iter<'_> {
+        Iter::new(&self)
+    }
 }
 
 impl From<(ValidatorDesc, ValidatorDesc)> for SpecValidators {
@@ -159,10 +163,44 @@ impl From<(ValidatorDesc, ValidatorDesc)> for SpecValidators {
 /// Fixed size iterator of 2, as we need an iterator in couple of occasions
 impl<'a> IntoIterator for &'a SpecValidators {
     type Item = &'a ValidatorDesc;
-    type IntoIter = ::std::vec::IntoIter<Self::Item>;
+    type IntoIter = Iter<'a>;
 
     fn into_iter(self) -> Self::IntoIter {
-        vec![self.leader(), self.follower()].into_iter()
+        self.iter()
+    }
+}
+
+pub struct Iter<'a> {
+    validators: &'a SpecValidators,
+    index: u8,
+}
+
+impl<'a> Iter<'a> {
+    fn new(validators: &'a SpecValidators) -> Self {
+        Self {
+            validators,
+            index: 0,
+        }
+    }
+}
+
+impl<'a> Iterator for Iter<'a> {
+    type Item = &'a ValidatorDesc;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        match self.index {
+            0 => {
+                self.index += 1;
+
+                Some(self.validators.leader())
+            }
+            1 => {
+                self.index += 1;
+
+                Some(self.validators.follower())
+            }
+            _ => None,
+        }
     }
 }
 

primitives/src/channel.rs

@@ -23,6 +23,7 @@ pub mod util {
 
     pub mod logging;
 }
+pub mod analytics;
 pub mod validator;
 
 pub use self::ad_unit::AdUnit;
@@ -42,7 +43,10 @@ pub enum DomainError {
 
 impl fmt::Display for DomainError {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(f, "Domain error",)
+        match self {
+            DomainError::InvalidArgument(err) => write!(f, "{}", err),
+            DomainError::RuleViolation(err) => write!(f, "{}", err),
+        }
     }
 }
 

primitives/src/lib.rs

@@ -35,7 +35,7 @@ lazy_static! {
         auth.insert("user".into(), "x8c9v1b2".into());
         auth.insert("publisher".into(), "testing".into());
         auth.insert("publisher2".into(), "testing2".into());
-        auth.insert("creator".into(), "awesomeCreator".into());
+        auth.insert("creator".into(), "0x033ed90e0fec3f3ea1c9b005c724d704501e0196".into());
         auth.insert("tester".into(), "AUTH_awesomeTester".into());
 
         auth

primitives/src/util/tests/prep_db.rs

@@ -32,18 +32,18 @@ impl ValidatorId {
     }
 }
 
-impl AsRef<[u8]> for ValidatorId {
-    fn as_ref(&self) -> &[u8] {
-        &self.0
-    }
-}
-
 impl From<&[u8; 20]> for ValidatorId {
     fn from(bytes: &[u8; 20]) -> Self {
         Self(*bytes)
     }
 }
 
+impl AsRef<[u8]> for ValidatorId {
+    fn as_ref(&self) -> &[u8] {
+        &self.0
+    }
+}
+
 impl TryFrom<&str> for ValidatorId {
     type Error = DomainError;
     fn try_from(value: &str) -> Result<Self, Self::Error> {