fix: apply proper formatting

Author: samparsky

primitives/src/analytics.rs

@@ -1,6 +1,6 @@
+use crate::ChannelId;
 use crate::DomainError;
 use serde::{Deserialize, Serialize};
-use crate::ChannelId;
 
 pub const ANALYTICS_QUERY_LIMIT: u32 = 200;
 
@@ -10,7 +10,7 @@ pub struct AnalyticsData {
     pub time: f64,
     pub value: String,
     #[serde(default, skip_serializing_if = "Option::is_none")]
-    pub channel_id: Option<ChannelId>
+    pub channel_id: Option<ChannelId>,
 }
 
 #[derive(Debug, Serialize, Deserialize)]
@@ -52,7 +52,7 @@ pub struct AnalyticsQuery {
 impl AnalyticsQuery {
     pub fn metric_to_column(&mut self) {
         self.metric = match self.metric.as_str() {
-            "eventCounts"=> "count".to_string(),
+            "eventCounts" => "count".to_string(),
             "eventPayouts" => "payout".to_string(),
             _ => "count".to_string(),
         };

primitives/src/validator.rs

@@ -174,11 +174,11 @@ pub enum MessageTypes {
 #[cfg(feature = "postgres")]
 pub mod postgres {
     use super::ValidatorId;
+    use crate::ToETHChecksum;
     use bytes::BytesMut;
     use postgres_types::{FromSql, IsNull, ToSql, Type};
     use std::convert::TryFrom;
     use std::error::Error;
-    use crate::ToETHChecksum;
 
     impl<'a> FromSql<'a> for ValidatorId {
         fn from_sql(ty: &Type, raw: &'a [u8]) -> Result<Self, Box<dyn Error + Sync + Send>> {

sentry/src/db/analytics.rs

@@ -3,7 +3,7 @@ use crate::epoch;
 use crate::Session;
 use bb8::RunError;
 use chrono::Utc;
-use primitives::analytics::{AnalyticsQuery, AnalyticsData, ANALYTICS_QUERY_LIMIT};
+use primitives::analytics::{AnalyticsData, AnalyticsQuery, ANALYTICS_QUERY_LIMIT};
 use primitives::sentry::{AdvancedAnalyticsResponse, ChannelReport, PublisherReport};
 use primitives::{ChannelId, ValidatorId};
 use redis;
@@ -12,13 +12,9 @@ use std::collections::HashMap;
 use std::error::Error;
 
 pub enum AnalyticsType {
-    Advertiser {
-        session: Session,
-    },
+    Advertiser { session: Session },
     Global,
-    Publisher {
-        session: Session,
-    },
+    Publisher { session: Session },
 }
 
 pub async fn advertiser_channel_ids(
@@ -70,31 +66,19 @@ pub async fn get_analytics(
                 ));
             }
 
-            where_clauses.push(format!(
-                "event_type = '{}'",
-                query.event_type
-            ));
+            where_clauses.push(format!("event_type = '{}'", query.event_type));
 
-            where_clauses.push(format!(
-                "{} IS NOT NULL",
-                query.metric
-            ));
+            where_clauses.push(format!("{} IS NOT NULL", query.metric));
 
             format!(
                 "SUM({}::numeric)::varchar as value, (extract(epoch from created) - (MOD( CAST (extract(epoch from created) AS NUMERIC), {}))) as time", 
                 query.metric, interval
             )
         }
-        AnalyticsType::Global  => {
-            where_clauses.push(format!(
-                "event_type = '{}'",
-                query.event_type
-            ));
+        AnalyticsType::Global => {
+            where_clauses.push(format!("event_type = '{}'", query.event_type));
 
-            where_clauses.push(format!(
-                "{} IS NOT NULL",
-                query.metric
-            ));
+            where_clauses.push(format!("{} IS NOT NULL", query.metric));
 
             where_clauses.push("earner IS NULL".to_string());
 
@@ -104,21 +88,12 @@ pub async fn get_analytics(
             )
         }
         AnalyticsType::Publisher { session } => {
-            where_clauses.push(format!(
-                "event_type = '{}'",
-                query.event_type
-            ));
+            where_clauses.push(format!("event_type = '{}'", query.event_type));
 
-            where_clauses.push(format!(
-                "{} IS NOT NULL",
-                query.metric
-            ));
+            where_clauses.push(format!("{} IS NOT NULL", query.metric));
+
+            where_clauses.push(format!("earner = '{}'", session.uid));
 
-            where_clauses.push(format!(
-                "earner = '{}'",
-                session.uid
-            ));
-            
             format!(
                 "SUM({}::numeric)::varchar as value, (extract(epoch from created) - (MOD( CAST (extract(epoch from created) AS NUMERIC), {}))) as time", 
                 query.metric, interval
@@ -139,8 +114,6 @@ pub async fn get_analytics(
         applied_limit,
     );
 
-    println!("{}", sql_query);
-
     // execute query
     pool.run(move |connection| async move {
         match connection.prepare(&sql_query).await {
@@ -202,7 +175,6 @@ pub async fn get_advanced_reports(
     publisher: &ValidatorId,
     channel_ids: &[ChannelId],
 ) -> Result<AdvancedAnalyticsResponse, Box<dyn Error>> {
-    println!("get advnaces");
     let publisher_reports = [
         PublisherReport::ReportPublisherToAdUnit,
         PublisherReport::ReportPublisherToAdSlot,
@@ -250,7 +222,6 @@ pub async fn get_advanced_reports(
 
         by_channel_stats.insert(channel_id.to_owned(), channel_stat);
     }
-    
 
     Ok(AdvancedAnalyticsResponse {
         publisher_stats,

sentry/src/lib.rs

@@ -57,7 +57,7 @@ lazy_static! {
     static ref CHANNEL_EVENTS_AGGREGATES: Regex = Regex::new(r"^/channel/0x([a-zA-Z0-9]{64})/events-aggregates/?$").expect("The regex should be valid");
     static ref ANALYTICS_BY_CHANNEL_ID: Regex = Regex::new(r"^/analytics/0x([a-zA-Z0-9]{64})/?$").expect("The regex should be valid");
     static ref ADVERTISER_ANALYTICS_BY_CHANNEL_ID: Regex = Regex::new(r"^/analytics/for-advertiser/0x([a-zA-Z0-9]{64})/?$").expect("The regex should be valid");
-    static ref PUBLISHER_ANALYTICS_BY_CHANNEL_ID: Regex = Regex::new(r"^/analytics/for-publisher/0x([a-zA-Z0-9]{64})/?$").expect("The regex should be valid");    
+    static ref PUBLISHER_ANALYTICS_BY_CHANNEL_ID: Regex = Regex::new(r"^/analytics/for-publisher/0x([a-zA-Z0-9]{64})/?$").expect("The regex should be valid");
     static ref CREATE_EVENTS_BY_CHANNEL_ID: Regex = Regex::new(r"^/channel/0x([a-zA-Z0-9]{64})/events(/.*)?$").expect("The regex should be valid");
 
 }
@@ -199,10 +199,12 @@ async fn analytics_router<A: Adapter + 'static>(
                     .map_or("".to_string(), |m| m.as_str().to_string())]);
                 req.extensions_mut().insert(param);
 
-                let req = chain(req, app, vec![
-                    Box::new(channel_load),
-                    Box::new(get_channel_id)
-                ]).await?;
+                let req = chain(
+                    req,
+                    app,
+                    vec![Box::new(channel_load), Box::new(get_channel_id)],
+                )
+                .await?;
 
                 analytics(req, app).await
             } else if let Some(caps) = ADVERTISER_ANALYTICS_BY_CHANNEL_ID.captures(route) {
@@ -211,10 +213,12 @@ async fn analytics_router<A: Adapter + 'static>(
                     .map_or("".to_string(), |m| m.as_str().to_string())]);
                 req.extensions_mut().insert(param);
 
-                let req = chain(req, app, vec![
-                    Box::new(auth_required_middleware),
-                    Box::new(get_channel_id)
-                ]).await?;
+                let req = chain(
+                    req,
+                    app,
+                    vec![Box::new(auth_required_middleware), Box::new(get_channel_id)],
+                )
+                .await?;
 
                 advertiser_analytics(req, app).await
             } else if let Some(caps) = PUBLISHER_ANALYTICS_BY_CHANNEL_ID.captures(route) {
@@ -223,10 +227,12 @@ async fn analytics_router<A: Adapter + 'static>(
                     .map_or("".to_string(), |m| m.as_str().to_string())]);
                 req.extensions_mut().insert(param);
 
-                let req = chain(req, app, vec![
-                    Box::new(auth_required_middleware),
-                    Box::new(get_channel_id)
-                ]).await?;
+                let req = chain(
+                    req,
+                    app,
+                    vec![Box::new(auth_required_middleware), Box::new(get_channel_id)],
+                )
+                .await?;
 
                 publisher_analytics(req, app).await
             } else {

sentry/src/middleware/auth.rs

@@ -23,7 +23,6 @@ pub(crate) async fn for_request(
         .and_then(|hv| {
             hv.to_str()
                 .map(|token_str| {
-                    println!("token str {}", token_str );
                     if token_str.starts_with(prefix) {
                         Some(token_str[prefix.len()..].to_string())
                     } else {

sentry/src/middleware/channel.rs

@@ -67,23 +67,22 @@ pub fn channel_if_active<'a, A: Adapter + 'static>(
     .boxed()
 }
 
-
 pub fn get_channel_id<'a, A: Adapter + 'static>(
     mut req: Request<Body>,
-    _: &'a Application<A> 
+    _: &'a Application<A>,
 ) -> BoxFuture<'a, Result<Request<Body>, ResponseError>> {
     async move {
         match req.extensions().get::<RouteParams>() {
-                Some(param) => {
-                    let id = param.get(0).expect("should have channel id");
-                    let channel_id = ChannelId::from_hex(id)
-                            .map_err(|_| ResponseError::BadRequest("Invalid Channel Id".to_string()))?;
-                    req.extensions_mut().insert(channel_id);
+            Some(param) => {
+                let id = param.get(0).expect("should have channel id");
+                let channel_id = ChannelId::from_hex(id)
+                    .map_err(|_| ResponseError::BadRequest("Invalid Channel Id".to_string()))?;
+                req.extensions_mut().insert(channel_id);
 
-                    Ok(req)
-                },
-                None => Ok(req),
+                Ok(req)
+            }
+            None => Ok(req),
         }
     }
     .boxed()
-}
+}

sentry/src/routes/analytics.rs

@@ -1,19 +1,18 @@
 use crate::db::analytics::{
-    advertiser_channel_ids, get_advanced_reports, get_analytics, AnalyticsType
+    advertiser_channel_ids, get_advanced_reports, get_analytics, AnalyticsType,
 };
 use crate::success_response;
 use crate::Application;
 use crate::ResponseError;
 use crate::RouteParams;
 use crate::Session;
 use hyper::{Body, Request, Response};
-use primitives::ChannelId;
 use primitives::adapter::Adapter;
 use primitives::analytics::{AnalyticsQuery, AnalyticsResponse};
+use primitives::ChannelId;
 use redis::aio::MultiplexedConnection;
 use slog::{error, Logger};
 
-
 pub async fn publisher_analytics<A: Adapter>(
     req: Request<Body>,
     app: &Application<A>,
@@ -44,7 +43,7 @@ pub async fn analytics<A: Adapter>(
         Ok(Some(response)) => Ok(success_response(response)),
         _ => {
             // checks if /:id route param is present
-            let cache_timeframe= match req.extensions().get::<RouteParams>() {
+            let cache_timeframe = match req.extensions().get::<RouteParams>() {
                 Some(_) => 600,
                 None => 300,
             };
@@ -85,7 +84,7 @@ pub async fn process_analytics<A: Adapter>(
     query
         .is_valid()
         .map_err(|e| ResponseError::BadRequest(e.to_string()))?;
-    
+
     query.metric_to_column();
 
     let channel_id = req.extensions().get::<ChannelId>();
@@ -97,12 +96,16 @@ pub async fn process_analytics<A: Adapter>(
         .unwrap_or_else(|| false);
     let limit = query.limit;
 
-    let aggr = get_analytics(query, &app.pool, analytics_type, segment_channel, channel_id).await?;
+    let aggr = get_analytics(
+        query,
+        &app.pool,
+        analytics_type,
+        segment_channel,
+        channel_id,
+    )
+    .await?;
 
-    let response = AnalyticsResponse {
-        limit,
-        aggr
-    };
+    let response = AnalyticsResponse { limit, aggr };
 
     serde_json::to_string(&response)
         .map_err(|_| ResponseError::BadRequest("error occurred; try again later".to_string()))
@@ -117,9 +120,14 @@ pub async fn advanced_analytics<A: Adapter>(
 
     let query = serde_urlencoded::from_str::<AnalyticsQuery>(&req.uri().query().unwrap_or(""))?;
 
-    let response = get_advanced_reports(&app.redis, &query.event_type, &sess.uid, &advertiser_channels)
-        .await
-        .map_err(|_| ResponseError::BadRequest("error occurred; try again later".to_string()))?;
+    let response = get_advanced_reports(
+        &app.redis,
+        &query.event_type,
+        &sess.uid,
+        &advertiser_channels,
+    )
+    .await
+    .map_err(|_| ResponseError::BadRequest("error occurred; try again later".to_string()))?;
 
     Ok(success_response(serde_json::to_string(&response)?))
 }

sentry/src/routes/channel.rs

@@ -187,7 +187,7 @@ pub async fn insert_events<A: Adapter + 'static>(
     let into_body = req.into_body();
     let body = hyper::body::to_bytes(into_body).await?;
     let request_body = serde_json::from_slice::<HashMap<String, Vec<Event>>>(&body)?;
-    
+
     let events = request_body
         .get("events")
         .ok_or_else(|| ResponseError::BadRequest("invalid request".to_string()))?;