use Rules and impl ToSql for Rules

Author: elpiel

primitives/src/ad_unit.rs

@@ -45,6 +45,10 @@ pub struct AdUnit {
     #[serde(default)]
     pub archived: bool,
     /// UTC timestamp in milliseconds, changed every time modifiable property is changed
-    #[serde(default, with = "ts_milliseconds_option", skip_serializing_if = "Option::is_none")]
+    #[serde(
+        default,
+        with = "ts_milliseconds_option",
+        skip_serializing_if = "Option::is_none"
+    )]
     pub modified: Option<DateTime<Utc>>,
 }

primitives/src/channel.rs

@@ -8,7 +8,7 @@ use chrono::{DateTime, Utc};
 use serde::{Deserialize, Deserializer, Serialize};
 use serde_hex::{SerHex, StrictPfx};
 
-use crate::{targeting::Rule, AdUnit, BigNum, EventSubmission, ValidatorDesc, ValidatorId};
+use crate::{targeting::Rules, AdUnit, BigNum, EventSubmission, ValidatorDesc, ValidatorId};
 use hex::{FromHex, FromHexError};
 
 #[derive(Serialize, Deserialize, PartialEq, Eq, Copy, Clone, Hash)]
@@ -96,7 +96,7 @@ pub struct Channel {
     #[serde(with = "ts_seconds")]
     pub valid_until: DateTime<Utc>,
     #[serde(default)]
-    pub targeting_rules: Vec<Rule>,
+    pub targeting_rules: Rules,
     pub spec: ChannelSpec,
 }
 
@@ -181,7 +181,7 @@ pub struct ChannelSpec {
     #[serde(default, skip_serializing_if = "Vec::is_empty")]
     pub ad_units: Vec<AdUnit>,
     #[serde(default)]
-    pub targeting_rules: Vec<Rule>,
+    pub targeting_rules: Rules,
 }
 
 #[derive(Serialize, Deserialize, Debug, Clone, Eq, PartialEq)]
@@ -370,7 +370,7 @@ mod test {
 pub mod postgres {
     use super::ChannelId;
     use super::{Channel, ChannelSpec};
-    use crate::targeting::Rule;
+    use crate::targeting::Rules;
     use bytes::BytesMut;
     use hex::FromHex;
     use postgres_types::{accepts, to_sql_checked, FromSql, IsNull, Json, ToSql, Type};
@@ -385,7 +385,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,
+                targeting_rules: row.get::<_, Json<Rules>>("targeting_rules").0,
                 spec: row.get::<_, Json<ChannelSpec>>("spec").0,
             }
         }

primitives/src/sentry.rs

@@ -1,7 +1,7 @@
 use crate::validator::MessageTypes;
 use crate::{BigNum, Channel, ChannelId, ValidatorId};
 use chrono::{DateTime, Utc};
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize};
 use std::collections::HashMap;
 use std::fmt;
 use std::hash::Hash;
@@ -122,9 +122,21 @@ pub struct ChannelListResponse {
     pub channels: Vec<Channel>,
     pub total_pages: u64,
     pub total: u64,
+    // TODO:
+    #[serde(deserialize_with = "page_u64_from_string")]
     pub page: u64,
 }
 
+fn page_u64_from_string<'de, D>(deserializer: D) -> Result<u64, D::Error>
+where
+    D: Deserializer<'de>,
+{
+    let page_string = String::deserialize(deserializer)?;
+
+    // parse from `String` to `u64`
+    page_string.parse().map_err(serde::de::Error::custom)
+}
+
 #[derive(Serialize, Deserialize, Debug, PartialEq, Eq)]
 #[serde(rename_all = "camelCase")]
 pub struct LastApprovedResponse {

primitives/src/supermarket.rs

@@ -44,7 +44,7 @@ pub mod units_for_slot {
     pub mod response {
 
         use crate::{
-            targeting::{Input, Rule},
+            targeting::{Input, Rules},
             BigNum, ChannelId, ChannelSpec, SpecValidators, ValidatorId, IPFS,
         };
         use chrono::{
@@ -75,7 +75,7 @@ pub mod units_for_slot {
         pub struct Campaign {
             #[serde(flatten)]
             pub channel: Channel,
-            pub targeting_rules: Vec<Rule>,
+            pub targeting_rules: Rules,
             pub units_with_price: Vec<UnitsWithPrice>,
         }
 

primitives/src/targeting/eval.rs

@@ -79,15 +79,38 @@ mod rules {
         de::{SeqAccess, Visitor},
         Deserialize, Deserializer, Serialize,
     };
-    use std::fmt;
+    use std::{
+        fmt,
+        ops::{Deref, DerefMut},
+    };
 
     use super::Rule;
 
-    #[derive(Serialize, Debug, Clone, Eq, PartialEq)]
+    #[derive(Serialize, Debug, Default, Clone, Eq, PartialEq)]
     #[serde(transparent)]
     /// The Rules is just a `Vec<Rule>` with one difference:
     /// When Deserializing it will skip invalid `Rule` instead of returning an error
-    pub struct Rules(Vec<Rule>);
+    pub struct Rules(pub Vec<Rule>);
+
+    impl Rules {
+        pub fn new() -> Self {
+            Self(vec![])
+        }
+    }
+
+    impl Deref for Rules {
+        type Target = Vec<Rule>;
+
+        fn deref(&self) -> &Self::Target {
+            &self.0
+        }
+    }
+
+    impl DerefMut for Rules {
+        fn deref_mut(&mut self) -> &mut Self::Target {
+            &mut self.0
+        }
+    }
 
     impl<'de> Deserialize<'de> for Rules {
         fn deserialize<D>(deserializer: D) -> Result<Rules, D::Error>
@@ -1251,7 +1274,7 @@ pub mod postgres {
     use postgres_types::{accepts, to_sql_checked, IsNull, Json, ToSql, Type};
     use std::error::Error;
 
-    impl ToSql for Rule {
+    impl ToSql for Rules {
         fn to_sql(
             &self,
             ty: &Type,

primitives/src/util/tests/prep_db.rs

@@ -1,5 +1,6 @@
 use crate::{
     channel::{Pricing, PricingBounds},
+    targeting::Rules,
     BigNum, Channel, ChannelId, ChannelSpec, EventSubmission, SpecValidators, ValidatorDesc,
     ValidatorId, IPFS,
 };
@@ -64,15 +65,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![],
+            targeting_rules: Rules::new(),
             // 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_rules: Rules::new(),
                 event_submission: Some(EventSubmission { allow: vec![] }),
                 // July 29, 2019 7:00:00 AM
                 created: Utc.timestamp(1_564_383_600, 0),