stats endpoint

migrations/20210430032935_mcaptcha_pow_fetched_stats.sql

@@ -1,4 +1,4 @@
 CREATE TABLE IF NOT EXISTS mcaptcha_pow_fetched_stats (
 	config_id INTEGER references mcaptcha_config(config_id)  ON DELETE CASCADE,
-	fetched_at timestamptz NOT NULL DEFAULT now()
+	time timestamptz NOT NULL DEFAULT now()
 );

migrations/20210509135118_mcaptcha_pow_solved_stats.sql

@@ -1,4 +1,4 @@
 CREATE TABLE IF NOT EXISTS mcaptcha_pow_solved_stats (
 	config_id INTEGER references mcaptcha_config(config_id)  ON DELETE CASCADE,
-	solved_at timestamptz NOT NULL DEFAULT now()
+	time timestamptz NOT NULL DEFAULT now()
 );

migrations/20210509135154_mcaptcha_pow_confirmed_stats.sql

@@ -1,4 +1,4 @@
 CREATE TABLE IF NOT EXISTS mcaptcha_pow_confirmed_stats (
 	config_id INTEGER references mcaptcha_config(config_id)  ON DELETE CASCADE,
-	confirmed_at timestamptz NOT NULL DEFAULT now()
+	time timestamptz NOT NULL DEFAULT now()
 );

src/api/v1/mcaptcha/captcha.rs

@@ -23,12 +23,14 @@ use serde::{Deserialize, Serialize};
 
 use super::get_random;
 use crate::errors::*;
+use crate::stats::fetch::{Stats, StatsUnixTimestamp};
 use crate::AppData;
 
 pub mod routes {
     pub struct MCaptcha {
         pub delete: &'static str,
         pub update_key: &'static str,
+        pub stats: &'static str,
     }
 
     impl MCaptcha {
@@ -36,6 +38,7 @@ pub mod routes {
             MCaptcha {
                 update_key: "/api/v1/mcaptcha/update/key",
                 delete: "/api/v1/mcaptcha/delete",
+                stats: "/api/v1/mcaptcha/stats",
             }
         }
     }
@@ -44,6 +47,7 @@ pub mod routes {
 pub fn services(cfg: &mut web::ServiceConfig) {
     cfg.service(update_token);
     cfg.service(delete_mcaptcha);
+    cfg.service(get_stats);
 }
 
 #[derive(Clone, Debug, Deserialize, Serialize)]
@@ -241,6 +245,24 @@ async fn delete_mcaptcha(
     }
 }
 
+#[derive(Debug, Clone, Deserialize, Serialize)]
+pub struct StatsPayload {
+    pub key: String,
+}
+
+#[my_codegen::post(
+    path = "crate::V1_API_ROUTES.mcaptcha.stats",
+    wrap = "crate::CheckLogin"
+)]
+async fn get_stats(
+    payload: web::Json<StatsPayload>,
+    data: AppData,
+) -> ServiceResult<impl Responder> {
+    let stats = Stats::new(&payload.key, &data.db).await?;
+    let stats = StatsUnixTimestamp::from_stats(&stats);
+    Ok(HttpResponse::Ok().json(&stats))
+}
+
 // Workflow:
 // 1. Sign up
 // 2. Sign in
@@ -299,5 +321,17 @@ mod tests {
         .await;
         // if updated key doesn't exist in databse, a non 200 result will bereturned
         assert_eq!(get_token_resp.status(), StatusCode::OK);
+
+        // get stats
+        let paylod = StatsPayload { key: token_key.key };
+        let get_statis_resp = test::call_service(
+            &app,
+            post_request!(&paylod, ROUTES.mcaptcha.stats)
+                .cookie(cookies.clone())
+                .to_request(),
+        )
+        .await;
+        // if updated key doesn't exist in databse, a non 200 result will bereturned
+        assert_eq!(get_statis_resp.status(), StatusCode::OK);
     }
 }

src/api/v1/mcaptcha/levels.rs

@@ -1,19 +1,19 @@
 /*
-* Copyright (C) 2021  Aravinth Manivannan <realaravinth@batsense.net>
+ * Copyright (C) 2021  Aravinth Manivannan <realaravinth@batsense.net>
-*
+ *
-* This program is free software: you can redistribute it and/or modify
+ * This program is free software: you can redistribute it and/or modify
-* it under the terms of the GNU Affero General Public License as
+ * it under the terms of the GNU Affero General Public License as
-* published by the Free Software Foundation, either version 3 of the
+ * published by the Free Software Foundation, either version 3 of the
-* License, or (at your option) any later version.
+ * License, or (at your option) any later version.
-*
+ *
-* This program is distributed in the hope that it will be useful,
+ * This program is distributed in the hope that it will be useful,
-* but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-* GNU Affero General Public License for more details.
+ * GNU Affero General Public License for more details.
-*
+ *
-* You should have received a copy of the GNU Affero General Public License
+ * You should have received a copy of the GNU Affero General Public License
-* along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
+ */
 use actix_identity::Identity;
 use actix_web::{web, HttpResponse, Responder};
 use futures::future::try_join_all;

src/date.rs

@@ -0,0 +1,92 @@
+/*
+ * Copyright (C) 2021  Aravinth Manivannan <realaravinth@batsense.net>
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as
+ * published by the Free Software Foundation, either version 3 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+use sqlx::types::time::OffsetDateTime;
+
+pub struct Date {
+    pub time: OffsetDateTime,
+}
+
+pub const MINUTE: i64 = 60;
+pub const HOUR: i64 = MINUTE * 60;
+pub const DAY: i64 = HOUR * 24;
+pub const WEEK: i64 = DAY * 7;
+
+impl Date {
+    pub fn format(date: &OffsetDateTime) -> String {
+        let timestamp = date.unix_timestamp();
+        let now = OffsetDateTime::now_utc().unix_timestamp();
+
+        let difference = now - timestamp;
+
+        if difference >= 3 * WEEK {
+            date.format("%d-%m-%y")
+        } else if (DAY..(3 * WEEK)).contains(&difference) {
+            format!("{} days ago", date.hour())
+        } else if (HOUR..DAY).contains(&difference) {
+            format!("{} hours ago", date.hour())
+        } else if (MINUTE..HOUR).contains(&difference) {
+            format!("{} minutes ago", date.minute())
+        } else {
+            format!("{} seconds ago", date.second())
+        }
+    }
+
+    pub fn print_date(&self) -> String {
+        Self::format(&self.time)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn print_date_test() {
+        let mut n = Date {
+            time: OffsetDateTime::now_utc(),
+        };
+
+        let timestamp = n.time.unix_timestamp();
+        println!("timestamp: {}", timestamp);
+
+        // seconds test
+        assert!(n.print_date().contains("seconds ago"));
+        n.time = OffsetDateTime::from_unix_timestamp(timestamp - 5);
+        assert!(n.print_date().contains("seconds ago"));
+
+        // minutes test
+        n.time = OffsetDateTime::from_unix_timestamp(timestamp - MINUTE * 2);
+        assert!(n.print_date().contains("minutes ago"));
+        n.time = OffsetDateTime::from_unix_timestamp(timestamp - MINUTE * 56);
+        assert!(n.print_date().contains("minutes ago"));
+
+        // hours test
+        n.time = OffsetDateTime::from_unix_timestamp(timestamp - HOUR);
+        assert!(n.print_date().contains("hours ago"));
+        n.time = OffsetDateTime::from_unix_timestamp(timestamp - HOUR * 23);
+        assert!(n.print_date().contains("hours ago"));
+
+        // days test
+        n.time = OffsetDateTime::from_unix_timestamp(timestamp - 2 * WEEK);
+        assert!(n.print_date().contains("days ago"));
+
+        // date test
+        n.time = OffsetDateTime::from_unix_timestamp(timestamp - 6 * WEEK);
+        let date = n.time.format("%d-%m-%y");
+        assert!(n.print_date().contains(&date))
+    }
+}

src/main.rs

@@ -27,6 +27,7 @@ use log::info;
 
 mod api;
 mod data;
+mod date;
 mod docs;
 mod email;
 mod errors;

src/pages/panel/notifications.rs

@@ -21,14 +21,10 @@ use sailfish::TemplateOnce;
 use sqlx::types::time::OffsetDateTime;
 
 use crate::api::v1::notifications::get::{self, runner};
+use crate::date::Date;
 use crate::errors::PageResult;
 use crate::AppData;
 
-const MINUTE: i64 = 60;
-const HOUR: i64 = MINUTE * 60;
-const DAY: i64 = HOUR * 24;
-const WEEK: i64 = DAY * 7;
-
 #[derive(TemplateOnce)]
 #[template(path = "panel/notifications/index.html")]
 pub struct IndexPage {
@@ -64,23 +60,7 @@ impl From<get::Notification> for Notification {
 
 impl Notification {
     pub fn print_date(&self) -> String {
-        let date = self.received;
+        Date::format(&self.received)
-        let timestamp = self.received.unix_timestamp();
-        let now = OffsetDateTime::now_utc().unix_timestamp();
-
-        let difference = now - timestamp;
-
-        if difference >= 3 * WEEK {
-            date.format("%d-%m-%y")
-        } else if (DAY..(3 * WEEK)).contains(&difference) {
-            format!("{} days ago", date.hour())
-        } else if (HOUR..DAY).contains(&difference) {
-            format!("{} hours ago", date.hour())
-        } else if (MINUTE..HOUR).contains(&difference) {
-            format!("{} minutes ago", date.minute())
-        } else {
-            format!("{} seconds ago", date.second())
-        }
     }
 }
 
@@ -103,6 +83,7 @@ pub async fn notifications(data: AppData, id: Identity) -> PageResult<impl Respo
 #[cfg(test)]
 mod tests {
     use super::*;
+    use crate::date::*;
 
     #[test]
     fn print_date_test() {

src/stats/fetch.rs

@@ -1,37 +1,60 @@
 /*
-* Copyright (C) 2021  Aravinth Manivannan <realaravinth@batsense.net>
+ * Copyright (C) 2021  Aravinth Manivannan <realaravinth@batsense.net>
-*
+ *
-* This program is free software: you can redistribute it and/or modify
+ * This program is free software: you can redistribute it and/or modify
-* it under the terms of the GNU Affero General Public License as
+ * it under the terms of the GNU Affero General Public License as
-* published by the Free Software Foundation, either version 3 of the
+ * published by the Free Software Foundation, either version 3 of the
-* License, or (at your option) any later version.
+ * License, or (at your option) any later version.
-*
+ *
-* This program is distributed in the hope that it will be useful,
+ * This program is distributed in the hope that it will be useful,
-* but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-* GNU Affero General Public License for more details.
+ * GNU Affero General Public License for more details.
-*
+ *
-* You should have received a copy of the GNU Affero General Public License
+ * You should have received a copy of the GNU Affero General Public License
-* along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
+ */
-
+use actix_web::{web, HttpResponse, Responder};
 use serde::{Deserialize, Serialize};
 use sqlx::PgPool;
 
+use crate::date::Date;
 use crate::errors::*;
+use crate::AppData;
 
 #[derive(Debug, Clone, Deserialize, Serialize)]
-pub struct Stats {
+pub struct StatsUnixTimestamp {
     pub config_fetches: Vec<i64>,
     pub solves: Vec<i64>,
     pub confirms: Vec<i64>,
 }
 
+pub struct Stats {
+    pub config_fetches: Vec<Date>,
+    pub solves: Vec<Date>,
+    pub confirms: Vec<Date>,
+}
+
+#[derive(Debug, Clone, Deserialize, Serialize)]
+pub struct StatsPayload {
+    pub key: String,
+}
+
+#[my_codegen::post(path = "crate::V1_API_ROUTES.auth.login", wrap = "crate::CheckLogin")]
+async fn get_stats(
+    payload: web::Json<StatsPayload>,
+    data: AppData,
+) -> ServiceResult<impl Responder> {
+    let stats = Stats::new(&payload.key, &data.db).await?;
+    let stats = StatsUnixTimestamp::from_stats(&stats);
+    Ok(HttpResponse::Ok().json(&stats))
+}
+
 impl Stats {
     pub async fn new(key: &str, db: &PgPool) -> ServiceResult<Self> {
-        let config_fetches_fut = Self::fetch_config_fetched(key, db);
+        let config_fetches_fut = runners::fetch_config_fetched(key, db);
-        let solves_fut = Self::fetch_solve(key, db);
+        let solves_fut = runners::fetch_solve(key, db);
-        let confirms_fut = Self::fetch_confirm(key, db);
+        let confirms_fut = runners::fetch_confirm(key, db);
 
         let (config_fetches, solves, confirms) =
             futures::try_join!(config_fetches_fut, solves_fut, confirms_fut)?;
@@ -44,70 +67,81 @@ impl Stats {
 
         Ok(res)
     }
+}
 
+impl StatsUnixTimestamp {
+    pub fn from_stats(stats: &Stats) -> Self {
+        let config_fetches = Self::unix_timestamp(&stats.config_fetches);
+        let solves = Self::unix_timestamp(&stats.solves);
+        let confirms = Self::unix_timestamp(&stats.confirms);
+        Self {
+            config_fetches,
+            solves,
+            confirms,
+        }
+    }
+
+    /// featch PoWConfig confirms
+    #[inline]
+    fn unix_timestamp(dates: &Vec<Date>) -> Vec<i64> {
+        let mut res: Vec<i64> = Vec::with_capacity(dates.len());
+
+        dates
+            .iter()
+            .for_each(|record| res.push(record.time.unix_timestamp()));
+
+        res
+    }
+}
+
+pub mod runners {
+    use super::*;
     /// featch PoWConfig fetches
     #[inline]
     pub async fn fetch_config_fetched(
         key: &str,
         db: &PgPool,
-    ) -> ServiceResult<Vec<i64>> {
+    ) -> ServiceResult<Vec<Date>> {
-        let records = sqlx::query!(
+        let records = sqlx::query_as!(
-            "SELECT fetched_at FROM mcaptcha_pow_fetched_stats WHERE config_id = 
+            Date,
+            "SELECT time FROM mcaptcha_pow_fetched_stats WHERE config_id = 
         (SELECT config_id FROM mcaptcha_config where key = $1)",
             &key,
         )
         .fetch_all(db)
         .await?;
 
-        let mut res: Vec<i64> = Vec::with_capacity(records.len());
+        Ok(records)
-
-        records
-            .iter()
-            .for_each(|record| res.push(record.fetched_at.unix_timestamp()));
-
-        Ok(res)
     }
 
     /// featch PoWConfig solves
     #[inline]
-    pub async fn fetch_solve(key: &str, db: &PgPool) -> ServiceResult<Vec<i64>> {
+    pub async fn fetch_solve(key: &str, db: &PgPool) -> ServiceResult<Vec<Date>> {
-        //    "SELECT solved_at FROM mcaptcha_pow_solved_stats WHERE config_id =
+        let records = sqlx::query_as!(
-        //    (SELECT config_id FROM mcaptcha_config where key = $1)"
+            Date,
-        let records = sqlx::query!(
+            "SELECT time FROM mcaptcha_pow_solved_stats WHERE config_id = 
-            "SELECT solved_at FROM mcaptcha_pow_solved_stats WHERE config_id = 
         (SELECT config_id FROM mcaptcha_config where key = $1)",
             &key,
         )
         .fetch_all(db)
         .await?;
 
-        let mut res: Vec<i64> = Vec::with_capacity(records.len());
+        Ok(records)
-
-        records
-            .iter()
-            .for_each(|record| res.push(record.solved_at.unix_timestamp()));
-
-        Ok(res)
     }
 
     /// featch PoWConfig confirms
     #[inline]
-    pub async fn fetch_confirm(key: &str, db: &PgPool) -> ServiceResult<Vec<i64>> {
+    pub async fn fetch_confirm(key: &str, db: &PgPool) -> ServiceResult<Vec<Date>> {
-        let records = sqlx::query!(
+        let records = sqlx::query_as!(
-            "SELECT confirmed_at FROM mcaptcha_pow_confirmed_stats WHERE config_id = (
+            Date,
+            "SELECT time FROM mcaptcha_pow_confirmed_stats WHERE config_id = (
         SELECT config_id FROM mcaptcha_config where key = $1)",
             &key
         )
         .fetch_all(db)
         .await?;
 
-        let mut res: Vec<i64> = Vec::with_capacity(records.len());
+        Ok(records)
-
-        records
-            .iter()
-            .for_each(|record| res.push(record.confirmed_at.unix_timestamp()));
-
-        Ok(res)
     }
 }
 
@@ -148,5 +182,10 @@ mod tests {
         assert_eq!(stats.config_fetches.len(), 1);
         assert_eq!(stats.solves.len(), 1);
         assert_eq!(stats.confirms.len(), 1);
+
+        let ustats = StatsUnixTimestamp::from_stats(&stats);
+        assert_eq!(ustats.config_fetches.len(), 1);
+        assert_eq!(ustats.solves.len(), 1);
+        assert_eq!(ustats.confirms.len(), 1);
     }
 }