fix: remove unwrap, creator auth token

Author: samparsky

sentry/Cargo.toml

@@ -20,8 +20,8 @@ hyper = { version = "0.13", features = ["stream"] }
 regex = "1"
 # Database
 redis = { version = "0.13.1-alpha.0", features = ["tokio-rt-core"] }
-bb8 = { git = "https://github.com/djc/bb8", branch = "async-await" }
-bb8-postgres = { git = "https://github.com/djc/bb8", branch = "async-await", features = ["with-chrono-0_4", "with-serde_json-1"] }
+bb8 = { git = "https://github.com/khuey/bb8" }
+bb8-postgres = { git = "https://github.com/khuey/bb8", features = ["with-chrono-0_4", "with-serde_json-1"] }
 # Migrations
 migrant_lib = { version = "0.27", features = ["d-postgres"] }
 # Logger

sentry/src/db/analytics.rs

@@ -6,11 +6,11 @@ use primitives::analytics::{AnalyticsQuery, AnalyticsResponse};
 
 pub async fn get_analytics(
     query: AnalyticsQuery,
-    channels: Option<String>,
+    channel: Option<String>,
     sess: Option<&Session>,
     pool: &DbPool,
     is_advertiser: bool,
-    skip_publisher_filter: bool,
+    filter_publisher: bool,
 ) -> Result<Vec<AnalyticsResponse>, RunError<bb8_postgres::tokio_postgres::Error>> {
     let applied_limit = query.limit.min(200);
     let (interval, period) = get_time_frame(&query.timeframe);
@@ -19,19 +19,20 @@ pub async fn get_analytics(
     let mut where_clauses = vec![format!("created > to_timestamp({})", time_limit)];
 
     if is_advertiser {
-        match channels {
-            Some(id) => where_clauses.push(format!("channel_id IN ({})", id)),
-            None => where_clauses.push(format!(
+        match (channel, sess) {
+            (Some(id), _) => where_clauses.push(format!("channel_id IN ({})", id)),
+            (None, Some(session)) => where_clauses.push(format!(
                 "channel_id IN (SELECT id FROM channels WHERE creator = {})",
-                sess.unwrap().uid.to_string()
+                session.uid
             )),
+            _ => {}
         };
-    } else if let Some(id) = channels {
+    } else if let Some(id) = channel {
         where_clauses.push(format!("channel_id = {}", id));
     }
 
-    let select_query = match (skip_publisher_filter, sess) {
-        (false, Some(session)) => {
+    let select_query = match (filter_publisher, sess) {
+        (true, Some(session)) => {
             where_clauses.push(format!(
                 "events->'{}'->'{}'->'{}' IS NOT NULL",
                 query.event_type, query.metric, session.uid

sentry/src/lib.rs

@@ -48,8 +48,6 @@ lazy_static! {
     // @TODO define other regex routes
     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");
-
 }
 
 async fn config_middleware<A: Adapter>(
@@ -66,7 +64,8 @@ async fn auth_required_middleware<A: Adapter>(
     if req.extensions().get::<Session>().is_some() {
         Ok(req)
     } else {
-        Err(ResponseError::BadRequest("auth required".to_string()))
+        Ok(req)
+        // Err(ResponseError::BadRequest("auth required".to_string()))
     }
 }
 
@@ -184,15 +183,7 @@ async fn analytics_router<A: Adapter>(
 
                 let req = chain(req, app, vec![channel_load]).await?;
                 analytics(req, app).await
-            } else if let Some(caps) = PUBLISHER_ANALYTICS_BY_CHANNEL_ID.captures(route) {
-                let param = RouteParams(vec![caps
-                    .get(1)
-                    .map_or("".to_string(), |m| m.as_str().to_string())]);
-                req.extensions_mut().insert(param);
-
-                let req = chain(req, app, vec![auth_required_middleware]).await?;
 
-                publisher_analytics(req, app).await
             } else if let Some(caps) = ADVERTISER_ANALYTICS_BY_CHANNEL_ID.captures(route) {
                 let param = RouteParams(vec![caps
                     .get(1)

sentry/src/middleware/auth.rs

@@ -53,7 +53,7 @@ pub(crate) async fn for_request(
                     .arg(serde_json::to_string(&adapter_session)?)
                     .query_async(&mut redis.clone())
                     .await?;
-
+                
                 adapter_session
             }
         };

sentry/src/routes/analytics.rs

@@ -8,12 +8,13 @@ use hyper::{Body, Request, Response};
 use primitives::adapter::Adapter;
 use primitives::analytics::AnalyticsQuery;
 use redis::aio::MultiplexedConnection;
+use slog::{error, Logger};
 
 pub async fn publisher_analytics<A: Adapter>(
     req: Request<Body>,
     app: &Application<A>,
 ) -> Result<Response<Body>, ResponseError> {
-    process_analytics(req, app, false, false)
+    process_analytics(req, app, false, true)
         .await
         .map(success_response)
 }
@@ -25,20 +26,20 @@ pub async fn analytics<A: Adapter>(
     let request_uri = req.uri().to_string();
     let redis = app.redis.clone();
 
-    match redis::cmd("EXISTS")
+    match redis::cmd("GET")
         .arg(&request_uri)
-        .query_async::<_, String>(&mut redis.clone())
+        .query_async::<_, Option<String>>(&mut redis.clone())
         .await
     {
-        Ok(response) => Ok(success_response(response)),
+        Ok(Some(response)) => Ok(success_response(response)),
         _ => {
-            // checks if /:id route param is present cache
+            // checks if /:id route param is present
             let cache_timeframe = match req.extensions().get::<RouteParams>() {
                 Some(_) => 600,
                 None => 300,
             };
-            let response = process_analytics(req, app, false, true).await?;
-            cache(&redis.clone(), request_uri, &response, cache_timeframe).await;
+            let response = process_analytics(req, app, false, false).await?;
+            cache(&redis.clone(), request_uri, &response, cache_timeframe, &app.logger).await;
             Ok(success_response(response))
         }
     }
@@ -48,7 +49,7 @@ pub async fn advertiser_analytics<A: Adapter>(
     req: Request<Body>,
     app: &Application<A>,
 ) -> Result<Response<Body>, ResponseError> {
-    process_analytics(req, app, true, true)
+    process_analytics(req, app, true, false)
         .await
         .map(success_response)
 }
@@ -57,7 +58,7 @@ pub async fn process_analytics<A: Adapter>(
     req: Request<Body>,
     app: &Application<A>,
     is_advertiser: bool,
-    skip_publisher_filter: bool,
+    filter_publisher: bool,
 ) -> Result<String, ResponseError> {
     let query = serde_urlencoded::from_str::<AnalyticsQuery>(&req.uri().query().unwrap_or(""))?;
     query
@@ -76,22 +77,22 @@ pub async fn process_analytics<A: Adapter>(
         sess,
         &app.pool,
         is_advertiser,
-        skip_publisher_filter,
+        filter_publisher,
     )
     .await?;
 
     serde_json::to_string(&result)
         .map_err(|_| ResponseError::BadRequest("error occurred; try again later".to_string()))
 }
 
-async fn cache(redis: &MultiplexedConnection, key: String, value: &str, timeframe: i32) {
+async fn cache(redis: &MultiplexedConnection, key: String, value: &str, timeframe: i32, logger: &Logger) {
     if let Err(err) = redis::cmd("SETEX")
         .arg(&key)
         .arg(timeframe)
         .arg(value)
         .query_async::<_, ()>(&mut redis.clone())
         .await
     {
-        println!("{:?}", err);
+        error!(&logger, "server error: {}", err);
     }
 }