Add stats_single page & header with links

src/main.rs

@@ -59,7 +59,8 @@ async fn main() -> io::Result<()> {
                 routes::pages::index,
                 routes::pages::history,
                 routes::pages::session_edit,
-                routes::pages::stats::view,
+                routes::pages::stats::single_stats,
+                routes::pages::stats::all_stats,
                 routes::api::edit_session,
                 routes::api::create_category,
                 routes::api::start_session,

src/routes/pages.rs

@@ -3,8 +3,7 @@ pub mod stats;
 use crate::auth::Authorized;
 use crate::database::latest::trees::{categories, sessions};
 use crate::status_json::StatusJson;
-use bincode::deserialize;
-use bincode::serialize;
+use bincode::{deserialize, serialize};
 use rocket::http::Status;
 use rocket::{get, State};
 use rocket_contrib::templates::Template;

src/routes/pages/stats.rs

@@ -1,35 +1,120 @@
 use crate::auth::Authorized;
 use crate::database::latest::trees::{categories, sessions};
 use crate::status_json::StatusJson;
-use bincode::deserialize;
+use bincode::{deserialize, serialize};
 use chrono::{DateTime, Local, Timelike};
+use rocket::http::Status;
 use rocket::{get, State};
 use rocket_contrib::templates::Template;
+use rocket_contrib::uuid::Uuid;
 use serde_derive::{Deserialize, Serialize};
 use std::cmp::Ordering;
 use std::collections::{BTreeMap, HashMap};
 
+#[derive(Debug, Serialize, Deserialize)]
+struct CategoryStatsContext {
+    category_id: categories::K,
+    category: categories::V,
+
+    last_session_start: Option<DateTime<Local>>,
+    secs_last_session: u64,
+    secs_last_week: u64,
+    secs_last_month: u64,
+
+    bars_max: f64,
+    bars: Vec<(u32, f64, f64)>,
+}
+
+fn sum_sessions<'a>(iter: impl IntoIterator<Item = &'a sessions::V>) -> u64 {
+    iter.into_iter()
+        .map(|session| session.ended - session.started)
+        .map(|duration| duration.num_seconds() as u64)
+        .sum()
+}
+
+#[get("/stats/<category_uuid>")]
+pub fn single_stats(
+    _auth: Authorized,
+    category_uuid: Uuid,
+    db: State<'_, sled::Db>,
+) -> Result<Template, StatusJson> {
+    let category_uuid_s = sled::IVec::from(serialize(&category_uuid.into_inner())?);
+
+    let categories_tree = db.open_tree(categories::NAME)?;
+    let sessions_tree = db.open_tree(sessions::NAME)?;
+
+    let category: categories::V = match categories_tree.get(category_uuid_s)? {
+        None => Err(Status::NotFound)?,
+        Some(data) => deserialize(&data).unwrap(),
+    };
+
+    let sessions: HashMap<sessions::K, sessions::V> = sessions_tree
+        .iter()
+        .map(|result| {
+            result.map(|(k, v)| deserialize(&k).and_then(|k| deserialize(&v).map(|v| (k, v))))
+        })
+        .collect::<Result<Result<_, _>, _>>()??;
+
+    let my_sessions = sessions
+        .values()
+        .filter(|session| session.category == *category_uuid);
+
+    let last_session = my_sessions.clone().max_by_key(|session| &session.started);
+
+    let secs_last_session = sum_sessions(last_session);
+
+    let now = Local::now();
+
+    let secs_last_week = sum_sessions(
+        my_sessions
+            .clone()
+            .filter(|session| (now - session.started) <= chrono::Duration::days(7)),
+    );
+
+    let secs_last_month = sum_sessions(
+        my_sessions
+            .clone()
+            .filter(|session| (now - session.started) <= chrono::Duration::days(30)),
+    );
+
+    let mut stats_per_hour = compute_percentage_per_hour(my_sessions);
+    let biggest_hour = *stats_per_hour
+        .values()
+        .max_by(|f1, f2| match () {
+            _ if f1 == f2 => Ordering::Equal,
+            _ if f1 > f2 => Ordering::Greater,
+            _ => Ordering::Less,
+        })
+        .unwrap_or(&1.0);
+
+    let context = CategoryStatsContext {
+        category_id: *category_uuid,
+        category,
+
+        last_session_start: last_session.map(|session| session.started),
+        secs_last_session,
+        secs_last_week,
+        secs_last_month,
+
+        bars_max: biggest_hour,
+        bars: (0..24)
+            .map(|hour| {
+                let percentage = *stats_per_hour.entry(hour).or_default();
+                (hour, percentage, biggest_hour - percentage)
+            })
+            .collect(),
+    };
+
+    Ok(Template::render("stats_single", &context))
+}
+
 #[get("/stats")]
-pub fn view(_auth: Authorized, db: State<'_, sled::Db>) -> Result<Template, StatusJson> {
+pub fn all_stats(_auth: Authorized, db: State<'_, sled::Db>) -> Result<Template, StatusJson> {
     #[derive(Debug, Serialize, Deserialize)]
     struct StatsContext {
         categories_stats: Vec<CategoryStatsContext>,
     }
 
-    #[derive(Debug, Serialize, Deserialize)]
-    struct CategoryStatsContext {
-        category_id: categories::K,
-        category: categories::V,
-
-        last_session_start: Option<DateTime<Local>>,
-        secs_last_session: u64,
-        secs_last_week: u64,
-        secs_last_month: u64,
-
-        bars_max: f64,
-        bars: Vec<(u32, f64, f64)>,
-    }
-
     let now = Local::now();
 
     let categories_tree = db.open_tree(categories::NAME)?;
@@ -52,13 +137,6 @@ pub fn view(_auth: Authorized, db: State<'_, sled::Db>) -> Result<Template, Stat
     let mut categories_stats: Vec<_> = categories
         .into_iter()
         .map(|(category_id, category)| {
-            fn sum_sessions<'a>(iter: impl IntoIterator<Item = &'a sessions::V>) -> u64 {
-                iter.into_iter()
-                    .map(|session| session.ended - session.started)
-                    .map(|duration| duration.num_seconds() as u64)
-                    .sum()
-            }
-
             let my_sessions = sessions
                 .values()
                 .filter(|session| session.category == category_id);
@@ -113,7 +191,7 @@ pub fn view(_auth: Authorized, db: State<'_, sled::Db>) -> Result<Template, Stat
 
     let context = StatsContext { categories_stats };
 
-    Ok(Template::render("stats", &context))
+    Ok(Template::render("stats_all", &context))
 }
 
 fn compute_percentage_per_hour<'a, I>(sessions: I) -> BTreeMap<u32, f64>
@@ -163,8 +241,7 @@ where
         }
     }
 
-    dbg!(&stats_per_hour);
-    let sum_weight: f64 = dbg!(stats_per_hour.values().sum());
+    let sum_weight: f64 = stats_per_hour.values().sum();
     for weight in stats_per_hour.values_mut() {
         *weight = *weight * 100.0 / sum_weight;
         *weight = (*weight * 10.0).trunc() / 10.0;