Refactor TryGet to Input::try_get

Author: elpiel

primitives/src/targeting.rs

@@ -35,6 +35,73 @@ pub struct Input {
     pub ad_slot: Option<AdSlot>,
 }
 
+impl Input {
+    fn try_get(&self, key: &str) -> Result<Value, Error> {
+        match key {
+            "adView.secondsSinceShow" => self
+                .ad_view
+                .as_ref()
+                .map(|ad_view| Value::Number(ad_view.seconds_since_show.into()))
+                .ok_or(Error::UnknownVariable),
+            "adView.hasCustomPreferences" => self
+                .ad_view
+                .as_ref()
+                .map(|ad_view| Value::Bool(ad_view.has_custom_preferences))
+                .ok_or(Error::UnknownVariable),
+            "adSlotId" => Ok(Value::String(self.global.ad_slot_id.clone())),
+            "adUnitId" => Ok(Value::String(self.global.ad_unit_id.clone())),
+            "adUnitType" => Ok(Value::String(self.global.ad_unit_type.clone())),
+            "publisherId" => Ok(Value::String(self.global.publisher_id.clone())),
+            "advertiserId" => Ok(Value::String(self.global.advertiser_id.clone())),
+            "country" => Ok(Value::String(self.global.country.clone())),
+            "eventType" => Ok(Value::String(self.global.event_type.clone())),
+            "campaignId" => Ok(Value::String(self.global.campiagn_id.clone())),
+            "campaignTotalSpent" => Ok(Value::String(self.global.campaign_total_spent.clone())),
+            "campaignSecondsActive" => {
+                Ok(Value::Number(self.global.campaign_seconds_active.into()))
+            }
+            "campaignSecondsDuration" => {
+                Ok(Value::Number(self.global.campaign_seconds_duration.into()))
+            }
+            "campaignBudget" => Ok(Value::BigNum(self.global.campaign_budget.clone())),
+            "eventMinPrice" => Ok(Value::BigNum(self.global.event_min_price.clone())),
+            "eventMaxPrice" => Ok(Value::BigNum(self.global.event_max_price.clone())),
+            "publisherEarnedFromCampaign" => Ok(Value::BigNum(
+                self.global.publisher_earned_from_campaign.clone(),
+            )),
+            "secondsSinceEpoch" => Ok(Value::Number(self.global.seconds_since_epoch.into())),
+            "userAgentOS" => Ok(Value::String(self.global.user_agent_os.clone())),
+            "userAgentBrowserFamily" => Ok(Value::String(self.global.user_agent_browser_family.clone())),
+            "adSlot.categories" => self
+                .ad_slot
+                .as_ref()
+                .map(|ad_slot| {
+                    let array = ad_slot
+                        .categories
+                        .iter()
+                        .map(|string| Value::String(string.clone()))
+                        .collect();
+                    Value::Array(array)
+                })
+                .ok_or(Error::UnknownVariable),
+            "adSlot.hostname" => self
+                .ad_slot
+                .as_ref()
+                .map(|ad_slot| Value::String(ad_slot.hostname.clone()))
+                .ok_or(Error::UnknownVariable),
+            "adSlot.alexaRank" => {
+                let ad_slot = self.ad_slot.as_ref().ok_or(Error::UnknownVariable)?;
+
+                match serde_json::Number::from_f64(ad_slot.alexa_rank) {
+                        Some(number) => Ok(Value::Number(number)),
+                        None => Err(Error::TypeError)
+                }
+            }
+            _unknown_field => Err(Error::UnknownVariable),
+        }
+    }
+}
+
 #[derive(Debug, Serialize, Deserialize)]
 #[cfg_attr(test, derive(Default))]
 #[serde(rename_all = "camelCase")]
@@ -54,6 +121,7 @@ pub struct Global {
     pub advertiser_id: String,
     pub country: String,
     pub event_type: String,
+    pub campiagn_id: String,
     pub campaign_total_spent: String,
     pub campaign_seconds_active: u64,
     pub campaign_seconds_duration: u64,
@@ -76,11 +144,6 @@ pub struct AdSlot {
     pub alexa_rank: f64,
 }
 
-impl TryGet for Input {}
-impl TryGet for Global {}
-impl TryGet for AdView {}
-impl TryGet for AdSlot {}
-
 #[derive(Debug)]
 pub struct Output {
     /// Whether to show the ad
@@ -115,8 +178,7 @@ mod test {
             .try_get("adView.secondsSinceShow")
             .expect("Should get the ad_view.seconds_since_show field");
 
-        let expected_number =
-            serde_json::from_str::<serde_json::Number>("10").expect("Should create number");
+        let expected_number = serde_json::Number::from(10);
 
         assert_eq!(Value::Number(expected_number), ad_view_seconds_since_show);
 

primitives/src/targeting/eval.rs

@@ -52,45 +52,16 @@ impl Value {
     }
 }
 
-#[derive(Debug, Serialize, Deserialize, Clone, PartialEq, Eq)]
-#[serde(from = "BigNum")]
-/// Bn (BigNum) function.
-/// This struct is also used to parse the Input correctly for [`TryGet`](primitives::targeting::TryGet).
-///
-/// This type will be:
-/// - Deserialized from a normal `BigNum`
-///
-/// ```json
-/// { "some_big_num_field": "1000" }
-/// ```
-///
-/// - Serialized to:
-///
-/// ```json
-/// { "FUNC": { "bn": "1000" } }
-/// ```
-pub struct Bn {
-    #[serde(rename = "bn")]
-    pub big_num: BigNum,
-}
-
-impl From<BigNum> for Bn {
-    fn from(big_num: BigNum) -> Self {
-        Self { big_num }
-    }
-}
-
 #[derive(Debug, Serialize, Deserialize, Clone, PartialEq, Eq)]
 #[serde(rename_all = "camelCase")]
+// TODO: https://github.com/AdExNetwork/adex-validator-stack-rust/issues/296
 pub enum Function {
     If(Box<Rule>, Box<Rule>),
     And(Box<Rule>, Box<Rule>),
     Intersects(Box<Rule>, Box<Rule>),
     Get(String),
-    // TODO: set
-    // TODO: Add: div, mul, mod, add, sub, max, min
-    /// Bn (BigNum) function.
-    Bn(Bn),
+    /// Bn(Value) function.
+    Bn(Value),
 }
 
 impl From<Function> for Rule {
@@ -130,16 +101,7 @@ impl TryFrom<SerdeValue> for Value {
         match serde_value {
             SerdeValue::Bool(bool) => Ok(Self::Bool(bool)),
             SerdeValue::Number(number) => Ok(Self::Number(number)),
-            SerdeValue::String(string) => {
-                // we need to try and parse the String as a BigNum
-                // if it fails, then it's just a String
-                let big_num = BigNum::from_str(&string);
-
-                match big_num {
-                    Ok(big_num) => Ok(Value::BigNum(big_num)),
-                    Err(_) => Ok(Value::String(string)),
-                }
-            }
+            SerdeValue::String(string) => Ok(Value::String(string)),
             SerdeValue::Array(serde_array) => {
                 let array = serde_array
                     .into_iter()
@@ -220,7 +182,26 @@ fn eval(input: &Input, output: &mut Output, rule: &Rule) -> Result<Option<Value>
             Some(Value::Bool(a.iter().any(|x| b.contains(x))))
         }
         Function::Get(key) => Some(input.try_get(key)?),
-        Function::Bn(bn) => Some(Value::BigNum(bn.big_num.clone())),
+        Function::Bn(value) => {
+            let big_num = match value {
+                Value::String(string) => {
+                    let big_num =
+                        BigNum::from_str(string.as_str()).map_err(|_| Error::TypeError)?;
+
+                    Value::BigNum(big_num)
+                }
+                Value::BigNum(big_num) => Value::BigNum(big_num.clone()),
+                Value::Number(number) => {
+                    let big_num =
+                        BigNum::from_str(&number.to_string()).map_err(|_| Error::TypeError)?;
+
+                    Value::BigNum(big_num)
+                }
+                _ => return Err(Error::TypeError),
+            };
+
+            Some(big_num)
+        }
     };
 
     Ok(value)