Merge pull request #311 from AdExNetwork/channel-and-channel_spec-targeting_rules_fields

Channel and ChannelSpec targeting_rules fields

Author: elpiel

adapter/src/ethereum.rs

@@ -669,12 +669,14 @@ 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: Utc::now(),

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,
 }
 
@@ -171,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)]
@@ -339,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};
@@ -353,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/targeting/eval.rs

@@ -587,6 +587,26 @@ fn math_operator(lhs: Number, rhs: Number, ops: MathOperator) -> Result<Number,
     }
 }
 
+#[cfg(feature = "postgres")]
+pub mod postgres {
+    use super::*;
+    use bytes::BytesMut;
+    use postgres_types::{accepts, to_sql_checked, IsNull, Json, ToSql, Type};
+    use std::error::Error;
+
+    impl ToSql for Rule {
+        fn to_sql(
+            &self,
+            ty: &Type,
+            w: &mut BytesMut,
+        ) -> Result<IsNull, Box<dyn Error + Sync + Send>> {
+            Json(self).to_sql(ty, w)
+        }
+
+        accepts!(JSONB);
+        to_sql_checked!();
+    }
+}
 #[cfg(test)]
 mod test {
     use super::*;

primitives/src/util/tests/prep_db.rs

@@ -64,13 +64,15 @@ lazy_static! {
             creator: ValidatorId::try_from("033ed90e0fec3f3ea1c9b005c724d704501e0196").expect("Should be valid ValidatorId"),
             deposit_asset: "0x89d24A6b4CcB1B6fAA2625fE562bDD9a23260359".to_string(),
             deposit_amount: 1_000.into(),
+            targeting_rules: vec![],
             // UNIX timestamp for 2100-01-01
             valid_until: Utc.timestamp(4_102_444_800, 0),
             spec: ChannelSpec {
                 title: None,
                 validators: SpecValidators::new(DUMMY_VALIDATOR_LEADER.clone(), DUMMY_VALIDATOR_FOLLOWER.clone()),
                 max_per_impression: 10.into(),
                 min_per_impression: 1.into(),
+                targeting_rules: vec![],
                 targeting: vec![],
                 min_targeting_score: None,
                 event_submission: Some(EventSubmission { allow: vec![] }),

sentry/migrations/20190806011140_initial-tables/seed/up.sql

@@ -1,11 +1,12 @@
-INSERT INTO 
-channels 
-VALUES 
+INSERT INTO
+channels (id, creator, deposit_asset, deposit_amount, valid_until, targeting_rules, spec)
+VALUES
 (
-    '0x061d5e2a67d0a9a10f1c732bca12a676d83f79663a396f7d87b3e30b9b411088', 
-    '0x033ed90e0fec3f3ea1c9b005c724d704501e0196', 
-    '0x89d24A6b4CcB1B6fAA2625fE562bDD9a23260359', 
+    '0x061d5e2a67d0a9a10f1c732bca12a676d83f79663a396f7d87b3e30b9b411088',
+    '0x033ed90e0fec3f3ea1c9b005c724d704501e0196',
+    '0x89d24A6b4CcB1B6fAA2625fE562bDD9a23260359',
     '1000',
     to_timestamp(4102444800),
-    '{"minPerImpression":"1","maxPerImpression":"10","pricingBounds":{"CLICK":{"min":"0","max":"0"}},"withdrawPeriodStart":4073414400000,"validators":[{"id":"0xce07CbB7e054514D590a0262C93070D838bFBA2e","url":"http://localhost:8005","fee":"100"},{"id":"0xC91763D7F14ac5c5dDfBCD012e0D2A61ab9bDED3","url":"http://localhost:8006","fee":"100"}]}'
-);
+    '[]',
+    '{"targeting_rules": [], "minPerImpression":"1","maxPerImpression":"10","created":1564383600000,"pricingBounds":{"CLICK":{"min":"0","max":"0"}},"withdrawPeriodStart":4073414400000,"validators":[{"id":"0xce07CbB7e054514D590a0262C93070D838bFBA2e","url":"http://localhost:8005","fee":"100"},{"id":"0xC91763D7F14ac5c5dDfBCD012e0D2A61ab9bDED3","url":"http://localhost:8006","fee":"100"}]}'
+);

sentry/migrations/20200625092729_channel-targeting-rules/down.sql

@@ -0,0 +1 @@
+ALTER TABLE channels DROP COLUMN targeting_rules;

sentry/migrations/20200625092729_channel-targeting-rules/up.sql

@@ -0,0 +1 @@
+ALTER TABLE channels ADD COLUMN targeting_rules JSONB NOT NULL DEFAULT '[]';

sentry/src/db.rs

@@ -84,7 +84,10 @@ pub async fn setup_migrations(environment: &str) {
         };
     }
 
-    let mut migrations = vec![make_migration!("20190806011140_initial-tables")];
+    let mut migrations = vec![
+        make_migration!("20190806011140_initial-tables"),
+        make_migration!("20200625092729_channel-targeting-rules"),
+    ];
 
     if environment == "development" {
         // seeds database tables for testing

sentry/src/db/channel.rs

@@ -14,7 +14,7 @@ pub async fn get_channel_by_id(
     pool
         .run(move |connection| {
             async move {
-                match connection.prepare("SELECT id, creator, deposit_asset, deposit_amount, valid_until, spec FROM channels WHERE id = $1 LIMIT 1").await {
+                match connection.prepare("SELECT id, creator, deposit_asset, deposit_amount, valid_until, targeting_rules, spec FROM channels WHERE id = $1 LIMIT 1").await {
                     Ok(select) => match connection.query(&select, &[&id]).await {
                         Ok(results) => Ok((results.get(0).map(Channel::from), connection)),
                         Err(e) => Err((e, connection)),
@@ -35,7 +35,7 @@ pub async fn get_channel_by_id_and_validator(
         .run(move |connection| {
             async move {
                 let validator = serde_json::Value::from_str(&format!(r#"[{{"id": "{}"}}]"#, validator_id)).expect("Not a valid json");
-                let query = "SELECT id, creator, deposit_asset, deposit_amount, valid_until, spec FROM channels WHERE id = $1 AND spec->'validators' @> $2 LIMIT 1";
+                let query = "SELECT id, creator, deposit_asset, deposit_amount, valid_until, targeting_rules, spec FROM channels WHERE id = $1 AND spec->'validators' @> $2 LIMIT 1";
                 match connection.prepare(query).await {
                     Ok(select) => {
                         match connection.query(&select, &[&id, &validator]).await {
@@ -57,8 +57,8 @@ pub async fn insert_channel(
     pool
         .run(move |connection| {
             async move {
-                match connection.prepare("INSERT INTO channels (id, creator, deposit_asset, deposit_amount, valid_until, spec) values ($1, $2, $3, $4, $5, $6)").await {
-                    Ok(stmt) => match connection.execute(&stmt, &[&channel.id, &channel.creator, &channel.deposit_asset, &channel.deposit_amount, &channel.valid_until, &channel.spec]).await {
+                    match connection.prepare("INSERT INTO channels (id, creator, deposit_asset, deposit_amount, valid_until, targeting_rules, spec) values ($1, $2, $3, $4, $5, $6, $7)").await {
+                    Ok(stmt) => match connection.execute(&stmt, &[&channel.id, &channel.creator, &channel.deposit_asset, &channel.deposit_amount, &channel.valid_until, &channel.targeting_rules, &channel.spec]).await {
                         Ok(row) => {
                             let inserted = row == 1;
                             Ok((inserted, connection))
@@ -138,7 +138,7 @@ mod list_channels {
             .run(move |connection| {
                 async move {
                     // To understand why we use Order by, see Postgres Documentation: https://www.postgresql.org/docs/8.1/queries-limit.html
-                    let statement = format!("SELECT id, creator, deposit_asset, deposit_amount, valid_until, spec FROM channels WHERE {} ORDER BY spec->>'created' DESC LIMIT {} OFFSET {}", where_clauses.join(" AND "), limit, skip);
+                    let statement = format!("SELECT id, creator, deposit_asset, deposit_amount, valid_until, targeting_rules, spec FROM channels WHERE {} ORDER BY spec->>'created' DESC LIMIT {} OFFSET {}", where_clauses.join(" AND "), limit, skip);
                     match connection.prepare(&statement).await {
                         Ok(stmt) => {
                             match connection.query(&stmt, params.as_slice()).await {