Merge pull request #308 from AdExNetwork/supermarket-changes

Supermarket changes

Author: elpiel

adapter/src/ethereum.rs

@@ -669,15 +669,17 @@ mod test {
             deposit_asset: eth_checksum::checksum(&format!("{:?}", token_contract.address())),
             deposit_amount: 2_000.into(),
             valid_until: Utc::now() + Duration::days(2),
+            targeting_rules: vec![],
             spec: ChannelSpec {
                 title: None,
                 validators: SpecValidators::new(leader_validator_desc, follower_validator_desc),
                 max_per_impression: 10.into(),
                 min_per_impression: 10.into(),
                 targeting: vec![],
+                targeting_rules: vec![],
                 min_targeting_score: None,
                 event_submission: Some(EventSubmission { allow: vec![] }),
-                created: Some(Utc::now()),
+                created: Utc::now(),
                 active_from: None,
                 nonce: None,
                 withdraw_period_start: Utc::now() + Duration::days(1),

primitives/src/balances_map.rs

@@ -32,6 +32,10 @@ impl BalancesMap {
         self.0.get(key)
     }
 
+    pub fn contains_key(&self, key: &ValidatorId) -> bool {
+        self.0.contains_key(key)
+    }
+
     pub fn entry(&mut self, key: ValidatorId) -> Entry<'_, ValidatorId, BigNum> {
         self.0.entry(key)
     }

primitives/src/channel.rs

@@ -1,15 +1,16 @@
 use std::error::Error;
 use std::fmt;
+use std::ops::Deref;
 
 use chrono::serde::{ts_milliseconds, ts_milliseconds_option, ts_seconds};
 use chrono::{DateTime, Utc};
 use serde::{Deserialize, Deserializer, Serialize};
 use serde_hex::{SerHex, StrictPfx};
 
-use crate::big_num::BigNum;
-use crate::{AdUnit, EventSubmission, TargetingTag, ValidatorDesc, ValidatorId};
+use crate::{
+    targeting::Rule, AdUnit, BigNum, EventSubmission, TargetingTag, ValidatorDesc, ValidatorId,
+};
 use hex::{FromHex, FromHexError};
-use std::ops::Deref;
 
 #[derive(Serialize, Deserialize, PartialEq, Eq, Copy, Clone, Hash)]
 #[serde(transparent)]
@@ -84,6 +85,8 @@ pub struct Channel {
     pub deposit_amount: BigNum,
     #[serde(with = "ts_seconds")]
     pub valid_until: DateTime<Utc>,
+    #[serde(default)]
+    pub targeting_rules: Vec<Rule>,
     pub spec: ChannelSpec,
 }
 
@@ -116,6 +119,14 @@ impl PricingBounds {
 
         vec
     }
+
+    pub fn get(&self, event_type: &str) -> Option<&Pricing> {
+        match event_type {
+            "IMPRESSION" => self.impression.as_ref(),
+            "CLICK" => self.click.as_ref(),
+            _ => None,
+        }
+    }
 }
 
 #[derive(Serialize, Deserialize, Debug, Clone)]
@@ -141,14 +152,10 @@ pub struct ChannelSpec {
     #[serde(default, skip_serializing_if = "Option::is_none")]
     pub event_submission: Option<EventSubmission>,
     /// A millisecond timestamp of when the campaign was created
-    #[serde(
-        default,
-        skip_serializing_if = "Option::is_none",
-        with = "ts_milliseconds_option"
-    )]
-    pub created: Option<DateTime<Utc>>,
+    #[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
+    /// Used by the AdViewManager & Targeting AIP#31
     #[serde(
         default,
         skip_serializing_if = "Option::is_none",
@@ -167,6 +174,8 @@ pub struct ChannelSpec {
     /// An array of AdUnit (optional)
     #[serde(default, skip_serializing_if = "Vec::is_empty")]
     pub ad_units: Vec<AdUnit>,
+    #[serde(default)]
+    pub targeting_rules: Vec<Rule>,
     #[serde(default, skip_serializing_if = "Vec::is_empty")]
     pub price_multiplication_rules: Vec<PriceMultiplicationRules>,
     #[serde(default)]
@@ -335,6 +344,7 @@ impl Error for ChannelError {
 pub mod postgres {
     use super::ChannelId;
     use super::{Channel, ChannelSpec};
+    use crate::targeting::Rule;
     use bytes::BytesMut;
     use hex::FromHex;
     use postgres_types::{accepts, to_sql_checked, FromSql, IsNull, Json, ToSql, Type};
@@ -349,6 +359,7 @@ pub mod postgres {
                 deposit_asset: row.get("deposit_asset"),
                 deposit_amount: row.get("deposit_amount"),
                 valid_until: row.get("valid_until"),
+                targeting_rules: row.get::<_, Json<Vec<Rule>>>("targeting_rules").0,
                 spec: row.get::<_, Json<ChannelSpec>>("spec").0,
             }
         }

primitives/src/lib.rs

@@ -15,8 +15,10 @@ pub mod event_submission;
 pub mod market;
 pub mod merkle_tree;
 pub mod sentry;
+pub mod supermarket;
 pub mod targeting;
 pub mod targeting_tag;
+
 pub mod util {
     pub mod tests {
         pub mod prep_db;

primitives/src/sentry.rs

@@ -217,21 +217,16 @@ 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;
+    use chrono::{serde::ts_seconds, DateTime, Utc};
+    use serde::{Deserialize, Serialize};
 
-    #[derive(Debug, Deserialize)]
+    #[derive(Debug, Serialize, 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"
-        )]
+        #[serde(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

primitives/src/supermarket.rs

@@ -0,0 +1,41 @@
+use crate::{BalancesMap, Channel};
+
+#[derive(Debug, Clone)]
+pub struct Campaign {
+    pub channel: Channel,
+    pub status: Status,
+    pub balances: BalancesMap,
+}
+
+impl Campaign {
+    pub fn new(channel: Channel, status: Status, balances: BalancesMap) -> Self {
+        Self {
+            channel,
+            status,
+            balances,
+        }
+    }
+}
+
+#[derive(Debug, Eq, PartialEq, Clone)]
+pub enum Status {
+    // Active and Ready
+    Active,
+    Pending,
+    Initializing,
+    Waiting,
+    Finalized(Finalized),
+    Unsound {
+        disconnected: bool,
+        offline: bool,
+        rejected_state: bool,
+        unhealthy: bool,
+    },
+}
+
+#[derive(Debug, PartialEq, Eq, Clone)]
+pub enum Finalized {
+    Expired,
+    Exhausted,
+    Withdraw,
+}