Merge pull request #325 from AdExNetwork/issue-296-get-should-work-with-output

AIP#31 Issue #296 Function::Get should work with output

Author: elpiel

primitives/src/targeting.rs

@@ -6,6 +6,7 @@ use chrono::Utc;
 use std::collections::HashMap;
 
 pub use eval::*;
+use serde_json::Number;
 
 mod eval;
 
@@ -24,6 +25,7 @@ impl Input {
         let spec = &self.global.channel.spec;
 
         match key {
+            // AdView scope, accessible only on the AdView
             "adView.secondsSinceCampaignImpression" => self
                 .ad_view
                 .as_ref()
@@ -34,9 +36,22 @@ impl Input {
                 .as_ref()
                 .map(|ad_view| Value::Bool(ad_view.has_custom_preferences))
                 .ok_or(Error::UnknownVariable),
+            "adView.navigatorLanguage" => self
+                .ad_view
+                .as_ref()
+                .map(|ad_view| Value::String(ad_view.navigator_language.clone()))
+                .ok_or(Error::UnknownVariable),
+            // Global scope, accessible everywhere
             "adSlotId" => Ok(Value::String(self.global.ad_slot_id.clone())),
             "adSlotType" => Ok(Value::String(self.global.ad_slot_type.clone())),
             "publisherId" => Ok(Value::String(self.global.publisher_id.to_checksum())),
+            "country" => self
+                .global
+                .country
+                .clone()
+                .ok_or(Error::UnknownVariable)
+                .map(Value::String),
+            "eventType" => Ok(Value::String(self.global.event_type.clone())),
             "secondsSinceEpoch" => Ok(Value::Number(self.global.seconds_since_epoch.into())),
             "userAgentOS" => self
                 .global
@@ -50,7 +65,7 @@ impl Input {
                 .clone()
                 .map(Value::String)
                 .ok_or(Error::UnknownVariable),
-
+            // Global scope, accessible everywhere, campaign-dependant
             "adUnitId" => {
                 let ipfs = self
                     .global
@@ -112,6 +127,7 @@ impl Input {
 
                 Ok(Value::BigNum(earned))
             }
+            // adSlot scope, accessible on Supermarket and AdView
             "adSlot.categories" => self
                 .ad_slot
                 .as_ref()
@@ -213,6 +229,26 @@ pub struct Output {
     pub price: HashMap<String, BigNum>,
 }
 
+impl Output {
+    fn try_get(&self, key: &str) -> Result<Value, Error> {
+        match key {
+            "show" => Ok(Value::Bool(self.show)),
+            "boost" => {
+                let boost = Number::from_f64(self.boost).ok_or(Error::TypeError)?;
+                Ok(Value::Number(boost))
+            }
+            price_key if price_key.starts_with("price.") => {
+                let price = self
+                    .price
+                    .get(price_key.trim_start_matches("price."))
+                    .ok_or(Error::UnknownVariable)?;
+                Ok(Value::BigNum(price.clone()))
+            }
+            _ => Err(Error::UnknownVariable),
+        }
+    }
+}
+
 impl From<&Channel> for Output {
     fn from(channel: &Channel) -> Self {
         let price = match &channel.spec.pricing_bounds {
@@ -325,6 +361,26 @@ mod test {
         assert!(input.try_get("adSlot.alexaRank").is_ok());
     }
 
+    #[test]
+    fn test_try_get_of_output() {
+        let output = Output {
+            show: false,
+            boost: 5.5,
+            price: vec![("one".to_string(), 100.into())].into_iter().collect(),
+        };
+
+        assert_eq!(Ok(Value::Bool(false)), output.try_get("show"));
+        assert_eq!(
+            Ok(Value::Number(
+                Number::from_f64(5.5).expect("Should make a number")
+            )),
+            output.try_get("boost")
+        );
+        assert_eq!(Ok(Value::BigNum(100.into())), output.try_get("price.one"));
+        assert_eq!(Err(Error::UnknownVariable), output.try_get("price.unknown"));
+        assert_eq!(Err(Error::UnknownVariable), output.try_get("unknown"));
+    }
+
     #[test]
     fn test_output_from_channel() {
         use crate::channel::{Pricing, PricingBounds};

primitives/src/targeting/eval.rs

@@ -895,7 +895,9 @@ fn eval(input: &Input, output: &mut Output, rule: &Rule) -> Result<Option<Value>
                 .try_bignum()?;
             let deposit_asset = &input.global.channel.deposit_asset;
 
-            let divisor = DEPOSIT_ASSETS_MAP.get(deposit_asset).ok_or(Error::TypeError)?;
+            let divisor = DEPOSIT_ASSETS_MAP
+                .get(deposit_asset)
+                .ok_or(Error::TypeError)?;
             let amount_in_usd = amount.div(divisor).to_f64().ok_or(Error::TypeError)?;
             let amount_as_number = Number::from_f64(amount_in_usd).ok_or(Error::TypeError)?;
             Some(Value::Number(amount_as_number))
@@ -944,7 +946,11 @@ fn eval(input: &Input, output: &mut Output, rule: &Rule) -> Result<Option<Value>
 
             return Ok(None);
         }
-        Function::Get(key) => Some(input.try_get(key)?),
+        Function::Get(key) => match input.try_get(key) {
+            Ok(value) => Some(value),
+            Err(Error::UnknownVariable) => Some(output.try_get(key)?),
+            Err(e) => return Err(e),
+        },
         Function::Bn(value) => {
             let big_num = value.clone().try_bignum()?;
 

primitives/src/targeting/eval_test.rs

@@ -253,6 +253,28 @@ mod dsl_test {
 
         assert_eq!(Some(&BigNum::from(20)), output.price.get("IMPRESSION"));
     }
+
+    #[test]
+    fn test_get_eval() {
+        let input = get_default_input();
+        let mut output = Output {
+            show: true,
+            boost: 42.0,
+            price: Default::default(),
+        };
+
+        let input_country = Function::Get("country".to_string())
+            .eval(&input, &mut output)
+            .expect("Should get input.global.country");
+        assert_eq!(Some(Value::String("bg".to_string())), input_country);
+
+        let output_boost = Function::Get("boost".to_string())
+            .eval(&input, &mut output)
+            .expect("Should get output.boost");
+        let expected_output_boost = Number::from_f64(42.0).expect("should create Number");
+
+        assert_eq!(Some(Value::Number(expected_output_boost)), output_boost);
+    }
 }
 
 mod math_functions {
@@ -1063,9 +1085,12 @@ mod control_flow_and_logic {
             boost: 1.0,
             price: Default::default(),
         };
-        Rule::Function(Function::new_only_show_if(Value::Bool(true))).eval(&input, &mut output);
+        let result = Function::new_only_show_if(Value::Bool(true)).eval(&input, &mut output);
+        assert_eq!(Ok(None), result);
         assert!(output.show);
-        Rule::Function(Function::new_only_show_if(Value::Bool(false))).eval(&input, &mut output);
+
+        let result = Function::new_only_show_if(Value::Bool(false)).eval(&input, &mut output);
+        assert_eq!(Ok(None), result);
         assert!(!output.show);
     }
     #[test]
@@ -1317,7 +1342,9 @@ mod string_and_array {
         for (key, value) in &*DEPOSIT_ASSETS_MAP {
             input.global.channel.deposit_asset = key.to_string();
             let amount_crypto = BigNum::from(100).mul(value);
-            let amount_usd = Some(Value::Number(Number::from_f64(100.0).expect("should create a float")));
+            let amount_usd = Some(Value::Number(
+                Number::from_f64(100.0).expect("should create a float"),
+            ));
             let rule = Rule::Function(Function::new_get_price_in_usd(Rule::Value(Value::BigNum(
                 amount_crypto,
             ))));