Merge pull request #449 from AmbireTech/analytics-v5

Analytics recorder v5

Author: elpiel

primitives/src/analytics.rs

@@ -1,5 +1,5 @@
-use crate::ChannelId;
-use crate::DomainError;
+use crate::{ChannelId, DomainError};
+use parse_display::Display;
 use serde::{Deserialize, Serialize};
 
 pub const ANALYTICS_QUERY_LIMIT: u32 = 200;
@@ -21,8 +21,13 @@ pub struct AnalyticsResponse {
 
 #[cfg(feature = "postgres")]
 pub mod postgres {
-    use super::AnalyticsData;
-    use tokio_postgres::Row;
+    use super::{AnalyticsData, OperatingSystem};
+    use bytes::BytesMut;
+    use std::error::Error;
+    use tokio_postgres::{
+        types::{accepts, to_sql_checked, FromSql, IsNull, ToSql, Type},
+        Row,
+    };
 
     impl From<&Row> for AnalyticsData {
         fn from(row: &Row) -> Self {
@@ -33,6 +38,34 @@ pub mod postgres {
             }
         }
     }
+
+    impl<'a> FromSql<'a> for OperatingSystem {
+        fn from_sql(ty: &Type, raw: &'a [u8]) -> Result<Self, Box<dyn Error + Sync + Send>> {
+            let str_slice = <&str as FromSql>::from_sql(ty, raw)?;
+            let os = match str_slice {
+                "Other" => OperatingSystem::Other,
+                "Linux" => OperatingSystem::Linux,
+                _ => OperatingSystem::Whitelisted(str_slice.to_string()),
+            };
+
+            Ok(os)
+        }
+
+        accepts!(TEXT, VARCHAR);
+    }
+
+    impl ToSql for OperatingSystem {
+        fn to_sql(
+            &self,
+            ty: &Type,
+            w: &mut BytesMut,
+        ) -> Result<IsNull, Box<dyn Error + Sync + Send>> {
+            self.to_string().to_sql(ty, w)
+        }
+
+        accepts!(TEXT, VARCHAR);
+        to_sql_checked!();
+    }
 }
 
 #[derive(Debug, Deserialize)]
@@ -49,6 +82,95 @@ pub struct AnalyticsQuery {
     pub segment_by_channel: Option<String>,
 }
 
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Display, Hash, Eq)]
+#[serde(untagged, into = "String", from = "String")]
+pub enum OperatingSystem {
+    Linux,
+    #[display("{0}")]
+    Whitelisted(String),
+    Other,
+}
+
+impl Default for OperatingSystem {
+    fn default() -> Self {
+        Self::Other
+    }
+}
+
+impl From<String> for OperatingSystem {
+    fn from(operating_system: String) -> Self {
+        match operating_system.as_str() {
+            "Linux" => OperatingSystem::Linux,
+            "Other" => OperatingSystem::Other,
+            _ => OperatingSystem::Whitelisted(operating_system),
+        }
+    }
+}
+
+impl From<OperatingSystem> for String {
+    fn from(os: OperatingSystem) -> String {
+        os.to_string()
+    }
+}
+
+impl OperatingSystem {
+    pub const LINUX_DISTROS: [&'static str; 17] = [
+        "Arch",
+        "CentOS",
+        "Slackware",
+        "Fedora",
+        "Debian",
+        "Deepin",
+        "elementary OS",
+        "Gentoo",
+        "Mandriva",
+        "Manjaro",
+        "Mint",
+        "PCLinuxOS",
+        "Raspbian",
+        "Sabayon",
+        "SUSE",
+        "Ubuntu",
+        "RedHat",
+    ];
+    pub const WHITELISTED: [&'static str; 18] = [
+        "Android",
+        "Android-x86",
+        "iOS",
+        "BlackBerry",
+        "Chromium OS",
+        "Fuchsia",
+        "Mac OS",
+        "Windows",
+        "Windows Phone",
+        "Windows Mobile",
+        "Linux",
+        "NetBSD",
+        "Nintendo",
+        "OpenBSD",
+        "PlayStation",
+        "Tizen",
+        "Symbian",
+        "KAIOS",
+    ];
+
+    pub fn map_os(os_name: &str) -> OperatingSystem {
+        if OperatingSystem::LINUX_DISTROS
+            .iter()
+            .any(|distro| os_name.eq(*distro))
+        {
+            OperatingSystem::Linux
+        } else if OperatingSystem::WHITELISTED
+            .iter()
+            .any(|whitelisted| os_name.eq(*whitelisted))
+        {
+            OperatingSystem::Whitelisted(os_name.into())
+        } else {
+            OperatingSystem::Other
+        }
+    }
+}
+
 impl AnalyticsQuery {
     pub fn is_valid(&self) -> Result<(), DomainError> {
         let valid_event_types = ["IMPRESSION", "CLICK"];
@@ -96,3 +218,99 @@ fn default_metric() -> String {
 fn default_timeframe() -> String {
     "hour".into()
 }
+
+#[cfg(test)]
+mod test {
+    use super::*;
+    use crate::postgres::POSTGRES_POOL;
+    use once_cell::sync::Lazy;
+    use serde_json::{from_value, to_value, Value};
+    use std::collections::HashMap;
+
+    static TEST_CASES: Lazy<HashMap<String, (OperatingSystem, Value)>> = Lazy::new(|| {
+        vec![
+            // Whitelisted - Android
+            (
+                OperatingSystem::WHITELISTED[0].to_string(),
+                (
+                    OperatingSystem::Whitelisted("Android".into()),
+                    Value::String("Android".into()),
+                ),
+            ),
+            // Linux - Arch
+            (
+                OperatingSystem::LINUX_DISTROS[0].to_string(),
+                (OperatingSystem::Linux, Value::String("Linux".into())),
+            ),
+            // Other - OS xxxxx
+            (
+                "OS xxxxx".into(),
+                (OperatingSystem::Other, Value::String("Other".into())),
+            ),
+        ]
+        .into_iter()
+        .collect()
+    });
+
+    #[cfg(feature = "postgres")]
+    #[tokio::test]
+    async fn os_to_from_sql() {
+        let client = POSTGRES_POOL.get().await.unwrap();
+        let sql_type = "VARCHAR";
+
+        for (input, _) in TEST_CASES.iter() {
+            let actual_os = OperatingSystem::map_os(input);
+
+            // from SQL
+            {
+                let row_os: OperatingSystem = client
+                    .query_one(&*format!("SELECT '{}'::{}", actual_os, sql_type), &[])
+                    .await
+                    .unwrap()
+                    .get(0);
+
+                assert_eq!(
+                    &actual_os, &row_os,
+                    "expected and actual FromSql differ for {}",
+                    input
+                );
+            }
+
+            // to SQL
+            {
+                let row_os: OperatingSystem = client
+                    .query_one(&*format!("SELECT $1::{}", sql_type), &[&actual_os])
+                    .await
+                    .unwrap()
+                    .get(0);
+                assert_eq!(
+                    &actual_os, &row_os,
+                    "expected and actual ToSql differ for {}",
+                    input
+                );
+            }
+        }
+    }
+
+    #[test]
+    fn test_operating_system() {
+        for (input, (expect_os, expect_json)) in TEST_CASES.iter() {
+            let actual_os = OperatingSystem::map_os(input);
+
+            assert_eq!(
+                expect_os, &actual_os,
+                "expected and actual differ for {}",
+                input
+            );
+
+            let actual_json = to_value(&actual_os).expect("Should serialize it");
+
+            assert_eq!(expect_json, &actual_json);
+
+            let from_json: OperatingSystem =
+                from_value(actual_json).expect("Should deserialize it");
+
+            assert_eq!(expect_os, &from_json, "error processing {}", input);
+        }
+    }
+}

primitives/src/campaign.rs

@@ -29,7 +29,7 @@ mod campaign_id {
     use thiserror::Error;
     use uuid::Uuid;
 
-    #[derive(Debug, Clone, Copy, PartialEq, Eq)]
+    #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
     /// an Id of 16 bytes, (de)serialized as a `0x` prefixed hex
     /// In this implementation of the `CampaignId` the value is generated from a `Uuid::new_v4().to_simple()`
     pub struct CampaignId([u8; 16]);

primitives/src/ipfs.rs

@@ -91,6 +91,37 @@ impl Url {
     }
 }
 
+#[cfg(feature = "postgres")]
+mod postgres {
+    use super::IPFS;
+    use bytes::BytesMut;
+    use std::error::Error;
+    use tokio_postgres::types::{accepts, to_sql_checked, FromSql, IsNull, ToSql, Type};
+
+    impl ToSql for IPFS {
+        fn to_sql(
+            &self,
+            ty: &Type,
+            w: &mut BytesMut,
+        ) -> Result<IsNull, Box<dyn Error + Sync + Send>> {
+            self.0.to_string().to_sql(ty, w)
+        }
+
+        accepts!(TEXT, VARCHAR);
+        to_sql_checked!();
+    }
+
+    impl<'a> FromSql<'a> for IPFS {
+        fn from_sql(ty: &Type, raw: &'a [u8]) -> Result<Self, Box<dyn Error + Sync + Send>> {
+            let str_slice = <&str as FromSql>::from_sql(ty, raw)?;
+
+            Ok(str_slice.parse()?)
+        }
+
+        accepts!(TEXT, VARCHAR);
+    }
+}
+
 #[derive(Debug, Error)]
 pub enum UrlError {
     #[error("Parsing the IPFS Cid failed")]