fix: rename reports enum

Author: samparsky

primitives/src/sentry.rs

@@ -17,14 +17,14 @@ pub struct LastApproved {
 
 #[derive(Serialize, Deserialize, Debug)]
 pub struct NewStateValidatorMessage {
-    pub from: String,
+    pub from: ValidatorId,
     pub received: DateTime<Utc>,
     pub msg: MessageTypes,
 }
 
 #[derive(Serialize, Deserialize, Debug)]
 pub struct ApproveStateValidatorMessage {
-    pub from: String,
+    pub from: ValidatorId,
     pub received: DateTime<Utc>,
     pub msg: MessageTypes,
 }
@@ -170,39 +170,39 @@ pub struct AdvancedAnalyticsResponse {
 #[derive(Serialize, Deserialize, Debug, Hash, PartialEq, Eq, Clone)]
 #[serde(rename_all = "camelCase")]
 pub enum PublisherReport {
-    ReportPublisherToAdUnit,
-    ReportPublisherToAdSlot,
-    ReportPublisherToAdSlotPay,
-    ReportPublisherToCountry,
-    ReportPublisherToHostname,
+    AdUnit,
+    AdSlot,
+    AdSlotPay,
+    Country,
+    Hostname,
 }
 
 impl fmt::Display for PublisherReport {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match *self {
-            PublisherReport::ReportPublisherToAdUnit => write!(f, "reportPublisherToAdUnit"),
-            PublisherReport::ReportPublisherToAdSlot => write!(f, "reportPublisherToAdSlot"),
-            PublisherReport::ReportPublisherToAdSlotPay => write!(f, "reportPublisherToAdSlotPay"),
-            PublisherReport::ReportPublisherToCountry => write!(f, "reportPublisherToCountry"),
-            PublisherReport::ReportPublisherToHostname => write!(f, "reportPublisherToHostname"),
+            PublisherReport::AdUnit => write!(f, "reportPublisherToAdUnit"),
+            PublisherReport::AdSlot => write!(f, "reportPublisherToAdSlot"),
+            PublisherReport::AdSlotPay => write!(f, "reportPublisherToAdSlotPay"),
+            PublisherReport::Country => write!(f, "reportPublisherToCountry"),
+            PublisherReport::Hostname => write!(f, "reportPublisherToHostname"),
         }
     }
 }
 
 #[derive(Serialize, Deserialize, Debug, Hash, PartialEq, Eq, Clone)]
 #[serde(rename_all = "camelCase")]
 pub enum ChannelReport {
-    ReportChannelToAdUnit,
-    ReportChannelToHostname,
-    ReportChannelToHostnamePay,
+    AdUnit,
+    Hostname,
+    HostnamePay,
 }
 
 impl fmt::Display for ChannelReport {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match *self {
-            ChannelReport::ReportChannelToAdUnit => write!(f, "reportPublisherToAdUnit"),
-            ChannelReport::ReportChannelToHostname => write!(f, "reportChannelToHostname"),
-            ChannelReport::ReportChannelToHostnamePay => write!(f, "reportChannelToHostnamePay"),
+            ChannelReport::AdUnit => write!(f, "reportPublisherToAdUnit"),
+            ChannelReport::Hostname => write!(f, "reportChannelToHostname"),
+            ChannelReport::HostnamePay => write!(f, "reportChannelToHostnamePay"),
         }
     }
 }

sentry/src/analytics_recorder.rs

@@ -13,13 +13,11 @@ pub fn get_payout(channel: &Channel, event: &Event) -> BigNum {
         Event::Click { .. } => {
             if let Some(pricing) = channel.spec.pricing_bounds.clone() {
                 if let Some(click) = pricing.click {
-                    click.min
-                } else {
-                    BigNum::from(0)
+                    return click.min;
                 }
-            } else {
-                BigNum::from(0)
             }
+            
+            BigNum::from(0)
         }
         _ => BigNum::from(0),
     }
@@ -60,7 +58,7 @@ pub async fn record(
                     db.zincr(
                         format!(
                             "{}:{}:{}",
-                            PublisherReport::ReportPublisherToAdUnit,
+                            PublisherReport::AdUnit,
                             event,
                             publisher
                         ),
@@ -71,7 +69,7 @@ pub async fn record(
                     db.zincr(
                         format!(
                             "{}:{}:{}",
-                            ChannelReport::ReportChannelToAdUnit,
+                            ChannelReport::AdUnit,
                             event,
                             publisher
                         ),
@@ -85,7 +83,7 @@ pub async fn record(
                     db.zincr(
                         format!(
                             "{}:{}:{}",
-                            PublisherReport::ReportPublisherToAdSlot,
+                            PublisherReport::AdSlot,
                             event,
                             publisher
                         ),
@@ -96,7 +94,7 @@ pub async fn record(
                     db.zincr(
                         format!(
                             "{}:{}:{}",
-                            PublisherReport::ReportPublisherToAdSlotPay,
+                            PublisherReport::AdSlotPay,
                             event,
                             publisher
                         ),
@@ -110,7 +108,7 @@ pub async fn record(
                     db.zincr(
                         format!(
                             "{}:{}:{}:{}",
-                            PublisherReport::ReportPublisherToCountry,
+                            PublisherReport::Country,
                             epoch().floor(),
                             event,
                             publisher
@@ -130,7 +128,7 @@ pub async fn record(
                     db.zincr(
                         format!(
                             "{}:{}:{}",
-                            PublisherReport::ReportPublisherToHostname,
+                            PublisherReport::Hostname,
                             event,
                             publisher
                         ),
@@ -141,7 +139,7 @@ pub async fn record(
                     db.zincr(
                         format!(
                             "{}:{}:{}",
-                            ChannelReport::ReportChannelToHostname,
+                            ChannelReport::Hostname,
                             event,
                             channel.id
                         ),
@@ -152,7 +150,7 @@ pub async fn record(
                     db.zincr(
                         format!(
                             "{}:{}:{}",
-                            ChannelReport::ReportChannelToHostnamePay,
+                            ChannelReport::HostnamePay,
                             event,
                             channel.id
                         ),

sentry/src/db/analytics.rs

@@ -186,18 +186,18 @@ pub async fn get_advanced_reports(
     channel_ids: &[ChannelId],
 ) -> Result<AdvancedAnalyticsResponse, Box<dyn Error>> {
     let publisher_reports = [
-        PublisherReport::ReportPublisherToAdUnit,
-        PublisherReport::ReportPublisherToAdSlot,
-        PublisherReport::ReportPublisherToAdSlotPay,
-        PublisherReport::ReportPublisherToCountry,
-        PublisherReport::ReportPublisherToHostname,
+        PublisherReport::AdUnit,
+        PublisherReport::AdSlot,
+        PublisherReport::AdSlotPay,
+        PublisherReport::Country,
+        PublisherReport::Hostname,
     ];
 
     let mut publisher_stats: HashMap<PublisherReport, HashMap<String, f64>> = HashMap::new();
 
     for publisher_report in publisher_reports.iter() {
         let pair = match publisher_report {
-            PublisherReport::ReportPublisherToCountry => format!(
+            PublisherReport::Country => format!(
                 "{}:{}:{}:{}",
                 epoch().floor(),
                 publisher_report,
@@ -213,9 +213,9 @@ pub async fn get_advanced_reports(
     let mut by_channel_stats = HashMap::new();
 
     let channel_reports = [
-        ChannelReport::ReportChannelToAdUnit,
-        ChannelReport::ReportChannelToHostname,
-        ChannelReport::ReportChannelToHostnamePay,
+        ChannelReport::AdUnit,
+        ChannelReport::Hostname,
+        ChannelReport::HostnamePay,
     ];
 
     for channel_id in channel_ids {

sentry/src/lib.rs

@@ -417,7 +417,7 @@ pub fn success_response(response_body: String) -> Response<Body> {
 }
 
 pub fn epoch() -> f64 {
-    (Utc::now().timestamp() / 2_628_000_000) as f64
+    Utc::now().timestamp() as f64 / 2_628_000_000.0
 }
 
 // @TODO: Make pub(crate)