Analytics routes

docs/config/dev.toml

@@ -37,6 +37,7 @@ ethereum_adapter_relayer = 'https://goerli-relayer.adex.network'
 
 creators_whitelist = []
 validators_whitelist = []
+admins = ['0xce07CbB7e054514D590a0262C93070D838bFBA2e']
 
 [[token_address_whitelist]]
 # DAI

docs/config/ganache.toml

@@ -41,7 +41,7 @@ ethereum_adapter_relayer = 'http://localhost:8888'
 
 creators_whitelist = []
 validators_whitelist = []
-
+admins = ['0xce07CbB7e054514D590a0262C93070D838bFBA2e']
 
 [[token_address_whitelist]]
 # Mocked TOKEN

docs/config/prod.toml

@@ -38,7 +38,7 @@ ethereum_adapter_relayer = 'https://relayer.adex.network'
 
 creators_whitelist = []
 validators_whitelist = []
-
+admins = ['0x5d6A3F1AD7b124ecDFDf4841D9bB246eD5fBF04c']
 
 [[token_address_whitelist]]
 # DAI

primitives/src/analytics.rs

@@ -1,4 +1,5 @@
-use crate::{ChannelId, DomainError};
+use crate::ChannelId;
+use chrono::{DateTime, Utc};
 use parse_display::Display;
 use serde::{Deserialize, Serialize};
 
@@ -76,10 +77,72 @@ pub struct AnalyticsQuery {
     #[serde(default = "default_event_type")]
     pub event_type: String,
     #[serde(default = "default_metric")]
-    pub metric: String,
+    pub metric: Metric,
     #[serde(default = "default_timeframe")]
-    pub timeframe: String,
-    pub segment_by_channel: Option<String>,
+    pub timeframe: Timeframe,
+    pub segment_by: Option<String>,
+    pub start: Option<DateTime<Utc>>,
+    pub end: Option<DateTime<Utc>>,
+    // #[serde(default = "default_timezone")]
+    // pub timezone: String,
+    pub campaign_id: Option<String>,
+    pub ad_unit: Option<String>,
+    pub ad_slot: Option<String>,
+    pub ad_slot_type: Option<String>,
+    pub advertiser: Option<String>,
+    pub publisher: Option<String>,
+    pub hostname: Option<String>,
+    pub country: Option<String>,
+    pub os_name: Option<String>,
+}
+
+impl AnalyticsQuery {
+    pub fn keys(&self) -> Vec<String> {
+        let mut keys = vec![];
+        if self.campaign_id.is_some() {
+            keys.push("campaignId".into())
+        }
+        if self.ad_unit.is_some() {
+            keys.push("adUnit".into())
+        }
+        if self.ad_slot.is_some() {
+            keys.push("adslot".into())
+        }
+        if self.ad_slot_type.is_some() {
+            keys.push("adSlotType".into())
+        }
+        if self.advertiser.is_some() {
+            keys.push("advertiser".into())
+        }
+        if self.publisher.is_some() {
+            keys.push("publisher".into())
+        }
+        if self.hostname.is_some() {
+            keys.push("hostname".into())
+        }
+        if self.campaign_id.is_some() {
+            keys.push("country".into())
+        }
+        if self.campaign_id.is_some() {
+            keys.push("osName".into())
+        }
+        keys
+    }
+
+    pub fn try_get_key(&self, key: &str) -> &Option<String> {
+        match key {
+            "campaignId" => &self.campaign_id,
+            "adUnit" => &self.ad_unit,
+            "adSlot" => &self.ad_slot,
+            "adSlotType" => &self.ad_slot_type,
+            "advertiser" => &self.advertiser,
+            "publisher" => &self.publisher,
+            "hostname" => &self.hostname,
+            "country" => &self.country,
+            "osName" => &self.os_name,
+            _ => &None,
+        }
+    }
 }
 
 #[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Display, Hash, Eq)]
@@ -91,6 +154,34 @@ pub enum OperatingSystem {
     Other,
 }
 
+#[derive(Debug, Clone, Serialize, Deserialize, Display)]
+pub enum Timeframe {
+    Year,
+    Month,
+    Week,
+    Day,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, Display)]
+pub enum Metric {
+    Count,
+    Paid,
+}
+
+impl Timeframe {
+    pub fn get_period_in_hours(&self) -> i64 {
+        let hour = 1;
+        let day = 24 * hour;
+        let year = 365 * day;
+        match self {
+            Timeframe::Day => day,
+            Timeframe::Week => 7 * day,
+            Timeframe::Month => year / 12,
+            Timeframe::Year => year,
+        }
+    }
+}
+
 impl Default for OperatingSystem {
     fn default() -> Self {
         Self::Other
@@ -171,38 +262,6 @@ impl OperatingSystem {
     }
 }
 
-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
 }
@@ -211,14 +270,18 @@ fn default_event_type() -> String {
     "IMPRESSION".into()
 }
 
-fn default_metric() -> String {
-    "eventCounts".into()
+fn default_metric() -> Metric {
+    Metric::Count
 }
 
-fn default_timeframe() -> String {
-    "hour".into()
+fn default_timeframe() -> Timeframe {
+    Timeframe::Day
 }
 
+// fn default_timezone() -> String {
+//     "UTC".into()
+// }
+
 #[cfg(test)]
 mod test {
     use super::*;

primitives/src/config.rs

@@ -81,6 +81,7 @@ pub struct Config {
     pub ethereum_adapter_relayer: String,
     pub creators_whitelist: Vec<Address>,
     pub validators_whitelist: Vec<ValidatorId>,
+    pub admins: Vec<String>,
     #[serde(deserialize_with = "deserialize_token_whitelist")]
     pub token_address_whitelist: HashMap<Address, TokenInfo>,
 }

primitives/src/sentry.rs

@@ -203,6 +203,14 @@ pub struct Analytics {
     pub payout_count: u32,
 }
 
+// TODO: Verify this is the needed output
+#[derive(Serialize, Deserialize, Clone, Debug, PartialEq)]
+#[serde(rename_all = "camelCase")]
+pub struct FetchedAnalytics {
+    pub payout_amount: Option<UnifiedNum>,
+    pub payout_count: Option<u32>,
+}
+
 #[derive(Debug, Error, PartialEq, Eq)]
 #[error("Minutes ({minutes}), seconds ({seconds}) & nanoseconds ({nanoseconds}) should all be set to 0 (zero)")]
 pub struct DateHourError {
@@ -751,7 +759,7 @@ pub mod campaign_create {
 
 #[cfg(feature = "postgres")]
 mod postgres {
-    use super::{Analytics, DateHour, MessageResponse, ValidatorMessage};
+    use super::{Analytics, DateHour, FetchedAnalytics, MessageResponse, ValidatorMessage};
     use crate::{
         sentry::EventAggregate,
         validator::{messages::Type as MessageType, MessageTypes},
@@ -892,6 +900,15 @@ mod postgres {
         accepts!(TIMESTAMPTZ);
         to_sql_checked!();
     }
+
+    impl From<&Row> for FetchedAnalytics {
+        fn from(row: &Row) -> Self {
+            Self {
+                payout_amount: row.get("payout_amount"),
+                payout_count: Some(row.get::<_, i32>("payout_count").unsigned_abs()),
+            }
+        }
+    }
 }
 
 #[cfg(test)]