Input Source & Map

Author: elpiel

adview-manager/src/lib.rs

@@ -3,7 +3,7 @@
 
 use adex_primitives::{
     supermarket::units_for_slot::response::{AdUnit, Campaign, Response},
-    targeting::{AdView, Input},
+    targeting::{AdView, InputSource},
     BigNum, ChannelId, SpecValidators,
 };
 use chrono::{DateTime, Utc};
@@ -268,7 +268,7 @@ impl Manager {
         Self { options, history }
     }
 
-    pub fn get_targeting_input(&self, mut input: Input, channel_id: ChannelId) -> Input {
+    pub fn get_targeting_input(&self, mut input: InputSource, channel_id: ChannelId) -> InputSource {
         let seconds_since_campaign_impression = self
             .history
             .iter()

primitives/src/supermarket.rs

@@ -42,7 +42,7 @@ pub enum Finalized {
 
 pub mod units_for_slot {
     pub mod response {
-        use crate::{targeting::Rule, BigNum, ChannelId, ChannelSpec, SpecValidators, ValidatorId};
+        use crate::{targeting::{Input, Rule, InputMap}, BigNum, ChannelId, ChannelSpec, SpecValidators, ValidatorId};
         use chrono::{
             serde::{ts_milliseconds, ts_milliseconds_option},
             DateTime, Utc,
@@ -53,8 +53,7 @@ pub mod units_for_slot {
         #[derive(Debug, Serialize, Deserialize)]
         #[serde(rename_all = "camelCase")]
         pub struct Response {
-            // TODO: This should be Input, however, we only need the fields and not the Global: Channel, Status & BalancesMap
-            pub targeting_input_base: (),
+            pub targeting_input_base: InputMap,
             pub accepted_referrers: Vec<Url>,
             pub fallback_unit: AdUnit,
             pub campaigns: Vec<Campaign>,

primitives/src/targeting.rs

@@ -7,11 +7,40 @@ use std::collections::HashMap;
 
 pub use eval::*;
 use serde_json::Number;
+use serde::{Serialize};
 
 mod eval;
 
-#[derive(Debug, Clone)]
-pub struct Input {
+pub type InputMap = HashMap<String, Value>;
+
+#[derive(Debug)]
+pub enum Input {
+    Map {
+        inner: InputMap,
+        deposit_asset: String,
+    },
+    InputSource(InputSource),
+}
+
+impl Input {
+    pub fn get(&self, key: &str) -> Result<Value, Error> {
+        match self {
+            Input::Map{inner, ..} => inner.get(key).ok_or(Error::UnknownVariable).map(Clone::clone),
+            Input::InputSource(input) => input.try_get(key)
+        }
+    }
+
+    pub fn deposit_asset(&self) -> Value {
+        match self {
+            Input::Map{deposit_asset, ..} => Value::new_string(deposit_asset),
+            Input::InputSource(input) => Value::new_string(&input.global.channel.deposit_asset)
+        }
+    }
+}
+
+#[derive(Debug, Clone, Serialize)]
+#[serde(into = "InputMap")]
+pub struct InputSource {
     /// AdView scope, accessible only on the AdView
     pub ad_view: Option<AdView>,
     /// Global scope, accessible everywhere
@@ -20,7 +49,57 @@ pub struct Input {
     pub ad_slot: Option<AdSlot>,
 }
 
-impl Input {
+impl From<Input> for InputMap {
+    fn from(input: Input) -> Self {
+        let mut map = Self::new();
+
+        let fields = [
+            // AdView scope, accessible only on the AdView
+            "adView.secondsSinceCampaignImpression",
+            "adView.hasCustomPreferences",
+            "adView.navigatorLanguage",
+            // Global scope, accessible everywhere
+            "adSlotId",
+            "adSlotType",
+            "publisherId",
+            "country",
+            "eventType",
+            "secondsSinceEpoch",
+            "userAgentOS",
+            "userAgentBrowserFamily",
+            // Global scope, accessible everywhere, campaign-dependant
+            "adUnitId",
+            "advertiserId",
+            "campaignId",
+            "campaignTotalSpent",
+            "campaignSecondsActive",
+            "campaignSecondsDuration",
+            "campaignBudget",
+            "eventMinPrice",
+            "eventMaxPrice",
+            "publisherEarnedFromCampaign",
+            // adSlot scope, accessible on Supermarket and AdView
+            "adSlot.categories",
+            "adSlot.hostname",
+            "adSlot.alexaRank",
+        ];
+
+        for field in fields.iter() {
+            match input.try_get(field) {
+                Ok(value) => {
+                    // we don't care if there is an old value, there shouldn't be one!
+                    map.insert(field.to_string(), value);
+                },
+                // if there is an Error, it will be `UnknownVariable` and we just skip it
+                Err(_) => {},
+            }
+        }
+
+        map
+    }
+}
+
+impl InputSource {
     fn try_get(&self, key: &str) -> Result<Value, Error> {
         let spec = &self.global.channel.spec;
 
@@ -107,6 +186,7 @@ impl Input {
 
                 Ok(Value::Number(seconds.into()))
             }
+            "depositAsset" => Ok(Value::new_string(&self.global.channel.deposit_asset)),
             "campaignBudget" => Ok(Value::BigNum(self.global.channel.deposit_amount.clone())),
             "eventMinPrice" => {
                 let min = get_pricing_bounds(&self.global.channel, &self.global.event_type).min;

primitives/src/targeting/eval.rs

@@ -893,10 +893,10 @@ fn eval(input: &Input, output: &mut Output, rule: &Rule) -> Result<Option<Value>
                 .eval(input, output)?
                 .ok_or(Error::TypeError)?
                 .try_bignum()?;
-            let deposit_asset = &input.global.channel.deposit_asset;
+            let deposit_asset = input.deposit_asset()?.try_string()?;
 
             let divisor = DEPOSIT_ASSETS_MAP
-                .get(deposit_asset)
+                .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)?;