Add cli & lib crates

server/src/routes/api.rs

@@ -0,0 +1,267 @@
+use crate::auth::Authorized;
+use crate::database::latest::trees::{category, session};
+use crate::database::util::category::get_all_categories;
+use crate::routes::pages;
+use crate::status_json::StatusJson;
+use crate::util::EventNotifier;
+use bincode::{deserialize, serialize};
+use chrono::{Duration, Local, NaiveDateTime, TimeZone};
+use rocket::form::{Form, FromForm};
+use rocket::http::Status;
+use rocket::response::Redirect;
+use rocket::{get, post, uri, State};
+use rocket_contrib::json::Json;
+use rocket_contrib::uuid::Uuid;
+use sled::Transactional;
+use std::collections::HashMap;
+use stl_lib::wfe::WaitForEvent;
+
+#[get("/sessions")]
+pub fn get_sessions(
+    _auth: Authorized,
+    db: State<'_, sled::Db>,
+) -> Result<Json<HashMap<category::K, category::V>>, StatusJson> {
+    let categories_tree = db.open_tree(category::NAME)?;
+    Ok(Json(get_all_categories(&categories_tree)?))
+}
+
+#[derive(FromForm)]
+pub struct NewCategory {
+    name: String,
+    color: String,
+}
+
+#[post("/create_category", data = "<category>")]
+pub fn create_category(
+    _auth: Authorized,
+    category: Form<NewCategory>,
+    db: State<'_, sled::Db>,
+) -> Result<StatusJson, StatusJson> {
+    let category = category.into_inner();
+
+    let categories_tree = db.open_tree(category::NAME)?;
+    categories_tree.insert(
+        serialize(&uuid::Uuid::new_v4())?,
+        serialize(&category::V {
+            name: category.name,
+            description: None,
+            color: category.color,
+            started: None,
+            parent: None,
+            deleted: false,
+        })?,
+    )?;
+
+    Ok(Status::Ok.into())
+}
+
+#[post("/category/<category_uuid>/bump_session/minutes/<minutes>")]
+pub fn bump_session(
+    _auth: Authorized,
+    category_uuid: Uuid,
+    minutes: i64,
+    db: State<'_, sled::Db>,
+) -> Result<Redirect, StatusJson> {
+    let duration = Duration::minutes(minutes);
+    let category_uuid_s = sled::IVec::from(serialize(&category_uuid.into_inner())?);
+
+    let categories_tree = db.open_tree(category::NAME)?;
+
+    Ok((&categories_tree).transaction(|tx_categories| {
+        match tx_categories.get(&category_uuid_s)? {
+            None => return Ok(Err(Status::NotFound.into())),
+            Some(data) => {
+                let mut category: category::V = deserialize(&data).unwrap();
+                match category.started.as_mut() {
+                    Some(started) => {
+                        if let Some(new_started) = started.checked_sub_signed(duration) {
+                            *started = new_started;
+                            tx_categories
+                                .insert(&category_uuid_s, serialize(&category).unwrap())?;
+                        } else {
+                            return Ok(Err(StatusJson::new(
+                                Status::BadRequest,
+                                "Duration subtract resulted in overflow",
+                            )));
+                        }
+
+                        Ok(Ok(Redirect::to(uri!(pages::index))))
+                    }
+                    None => {
+                        return Ok(Err(StatusJson::new(
+                            Status::BadRequest,
+                            "No active session",
+                        )))
+                    }
+                }
+            }
+        }
+    })??)
+}
+
+#[post("/category/<category_uuid>/start_session")]
+pub fn start_session(
+    _auth: Authorized,
+    category_uuid: Uuid,
+    event_notifier: State<'_, EventNotifier>,
+    db: State<'_, sled::Db>,
+) -> Result<StatusJson, StatusJson> {
+    toggle_category_session(category_uuid, true, event_notifier, db)
+}
+
+#[post("/category/<category_uuid>/end_session")]
+pub fn end_session(
+    _auth: Authorized,
+    category_uuid: Uuid,
+    event_notifier: State<'_, EventNotifier>,
+    db: State<'_, sled::Db>,
+) -> Result<StatusJson, StatusJson> {
+    toggle_category_session(category_uuid, false, event_notifier, db)
+}
+
+pub fn toggle_category_session(
+    category_uuid: Uuid,
+    set_active: bool,
+    event_notifier: State<'_, EventNotifier>,
+    db: State<'_, sled::Db>,
+) -> Result<StatusJson, StatusJson> {
+    let category_uuid_s = sled::IVec::from(serialize(&category_uuid.into_inner())?);
+
+    let categories_tree = db.open_tree(category::NAME)?;
+    let sessions_tree = db.open_tree(session::NAME)?;
+
+    Ok(
+        (&categories_tree, &sessions_tree).transaction(|(tx_categories, tx_sessions)| {
+            match tx_categories.get(&category_uuid_s)? {
+                None => return Ok(Err(Status::NotFound)),
+                Some(data) => {
+                    let mut category: category::V = deserialize(&data).unwrap();
+                    let now = Local::now();
+
+                    match (set_active, category.started.take()) {
+                        (false, Some(started)) => {
+                            // only save sessions longer than 5 minutes
+                            let duration = now - started;
+                            if duration > Duration::minutes(5) {
+                                let session_uuid = serialize(&uuid::Uuid::new_v4()).unwrap();
+                                let session = session::V {
+                                    category: category_uuid.into_inner(),
+                                    started,
+                                    ended: now,
+                                    deleted: category.deleted,
+                                };
+                                tx_sessions.insert(session_uuid, serialize(&session).unwrap())?;
+                            }
+                        }
+                        (true, None) => {
+                            category.started = Some(now);
+                        }
+                        _ => {
+                            // Category is already in the correct state
+                            return Ok(Ok(Status::Ok.into()));
+                        }
+                    }
+
+                    tx_categories.insert(&category_uuid_s, serialize(&category).unwrap())?;
+                    event_notifier.notify_event();
+                }
+            }
+
+            Ok(Ok(Status::Ok.into()))
+        })??,
+    )
+}
+
+#[derive(Debug, FromForm)]
+pub struct EditSession {
+    category: Uuid,
+    started: String,
+    ended: String,
+    deleted: bool,
+}
+
+#[post("/session/<session_uuid>/edit", data = "<session>")]
+pub fn edit_session(
+    _auth: Authorized,
+    session_uuid: Uuid,
+    session: Form<EditSession>,
+    db: State<'_, sled::Db>,
+) -> Result<Redirect, StatusJson> {
+    let session_uuid_s = sled::IVec::from(serialize(&session_uuid.into_inner())?);
+
+    let session = session::V {
+        category: session.category.into_inner(),
+        started: Local
+            .from_local_datetime(&NaiveDateTime::parse_from_str(
+                &session.started,
+                "%Y-%m-%d %H:%M",
+            )?)
+            .unwrap(),
+        ended: Local
+            .from_local_datetime(&NaiveDateTime::parse_from_str(
+                &session.ended,
+                "%Y-%m-%d %H:%M",
+            )?)
+            .unwrap(),
+        deleted: session.deleted,
+    };
+
+    if session.started >= session.ended {
+        return Err(StatusJson::new(
+            Status::BadRequest,
+            "started must be earlier than ended",
+        ));
+    }
+
+    db.open_tree(session::NAME)?
+        .insert(session_uuid_s, serialize(&session)?)?;
+
+    // FIXME: Uuid does not implement FromUriParam for some reason... File an issue?
+    //Ok(Redirect::to(uri!(pages::session_edit: session_uuid)))
+    Ok(Redirect::to(format!("/session/{}/edit", session_uuid)))
+}
+
+#[post("/session/<session_uuid>/delete")]
+pub fn delete_session(
+    _auth: Authorized,
+    session_uuid: Uuid,
+    db: State<'_, sled::Db>,
+) -> Result<Redirect, StatusJson> {
+    let session_uuid_s = sled::IVec::from(serialize(&session_uuid.into_inner())?);
+
+    let sessions_tree = db.open_tree(session::NAME)?;
+
+    match sessions_tree.remove(session_uuid_s)? {
+        Some(_) => Ok(Redirect::to(uri!(pages::history))),
+        None => Err(Status::NotFound.into()),
+    }
+
+    // TODO: mark as deleted instead of removing
+    // Ok(sessions_tree.transaction(|tx_sessions| {
+    //     match tx_sessions.get(&session_uuid_s)? {
+    //         None => return Ok(Err(Status::NotFound)),
+    //         Some(data) => {
+    //             let mut session: session::V = deserialize(&data).unwrap();
+    //         }
+    //     }
+    //     Ok(Ok(Redirect::to(uri!(pages::history))))
+    // })??)
+}
+
+#[get("/wait_for_event?<timeout>")]
+pub async fn wait_for_event(
+    _auth: Authorized,
+    timeout: Option<u64>,
+    event_notifier: State<'_, EventNotifier>,
+) -> Json<WaitForEvent> {
+    use std::time::Duration;
+    match tokio::time::timeout(
+        Duration::from_secs(timeout.unwrap_or(30)),
+        event_notifier.wait_for_event(),
+    )
+    .await
+    {
+        Ok(_) => Json(WaitForEvent { timeout: false }),
+        Err(_) => Json(WaitForEvent { timeout: true }),
+    }
+}

server/src/routes/mod.rs

@@ -0,0 +1,2 @@
+pub mod api;
+pub mod pages;

server/src/routes/pages.rs

@@ -0,0 +1,113 @@
+pub mod stats;
+
+use crate::auth::Authorized;
+use crate::database::latest::trees::{category, session};
+use crate::status_json::StatusJson;
+use bincode::{deserialize, serialize};
+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::collections::HashMap;
+use std::time::Duration;
+
+#[get("/")]
+pub fn index(_auth: Authorized, db: State<'_, sled::Db>) -> Result<Template, StatusJson> {
+    #[derive(Debug, Serialize, Deserialize)]
+    struct TemplateContext {
+        categories: Vec<(category::K, category::V)>,
+    }
+
+    let categories_tree = db.open_tree(category::NAME)?;
+
+    let context = TemplateContext {
+        categories: categories_tree
+            .iter()
+            .map(|result| {
+                result.map(|(k, v)| deserialize(&k).and_then(|k| deserialize(&v).map(|v| (k, v))))
+            })
+            .collect::<Result<Result<_, _>, _>>()??,
+    };
+
+    Ok(Template::render("index", &context))
+}
+
+#[get("/session/<session_uuid>/edit")]
+pub fn session_edit(
+    _auth: Authorized,
+    session_uuid: Uuid,
+    db: State<'_, sled::Db>,
+) -> Result<Template, StatusJson> {
+    #[derive(Debug, Serialize, Deserialize)]
+    struct SessionPageContext {
+        session: session::V,
+        session_id: uuid::Uuid,
+    }
+
+    let session_uuid_s = sled::IVec::from(serialize(&session_uuid.into_inner())?);
+
+    let sessions_tree = db.open_tree(session::NAME)?;
+    match sessions_tree.get(session_uuid_s)? {
+        None => Err(Status::NotFound)?,
+        Some(data) => {
+            let context = SessionPageContext {
+                session: deserialize(&data).unwrap(),
+                session_id: session_uuid.into_inner(),
+            };
+
+            Ok(Template::render("edit_session", &context))
+        }
+    }
+}
+
+#[get("/history")]
+pub fn history(_auth: Authorized, db: State<'_, sled::Db>) -> Result<Template, StatusJson> {
+    #[derive(Debug, Serialize, Deserialize)]
+    struct HistoryEntryContext {
+        category: category::V,
+        session: session::V,
+        session_id: uuid::Uuid,
+        duration: Duration,
+    }
+
+    #[derive(Debug, Serialize, Deserialize)]
+    struct TemplateContext {
+        entries: Vec<HistoryEntryContext>,
+    }
+
+    let categories_tree = db.open_tree(category::NAME)?;
+    let sessions_tree = db.open_tree(session::NAME)?;
+
+    let categories: HashMap<category::K, category::V> = categories_tree
+        .iter()
+        .map(|result| {
+            result.map(|(k, v)| deserialize(&k).and_then(|k| deserialize(&v).map(|v| (k, v))))
+        })
+        .collect::<Result<Result<_, _>, _>>()??;
+
+    let sessions: HashMap<session::K, session::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 mut context = TemplateContext {
+        entries: sessions
+            .into_iter()
+            .map(|(session_id, session)| HistoryEntryContext {
+                duration: (session.ended - session.started).to_std().unwrap(),
+                category: categories.get(&session.category).unwrap().clone(),
+                session,
+                session_id,
+            })
+            .collect(),
+    };
+
+    // Newest entries first
+    context.entries.sort_by_key(|entry| entry.session.started);
+    context.entries.reverse();
+
+    Ok(Template::render("history", &context))
+}

server/src/routes/pages/stats.rs

@@ -0,0 +1,299 @@
+use crate::auth::Authorized;
+use crate::database::latest::trees::{category, session};
+use crate::database::util::category::get_category;
+use crate::status_json::StatusJson;
+use bincode::deserialize;
+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: category::K,
+    category: category::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 session::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 categories_tree = db.open_tree(category::NAME)?;
+    let sessions_tree = db.open_tree(session::NAME)?;
+
+    let category: category::V =
+        get_category(&categories_tree, &category_uuid)?.ok_or(Status::NotFound)?;
+
+    let sessions: HashMap<session::K, session::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 all_stats(_auth: Authorized, db: State<'_, sled::Db>) -> Result<Template, StatusJson> {
+    #[derive(Debug, Serialize, Deserialize)]
+    struct StatsContext {
+        categories_stats: Vec<CategoryStatsContext>,
+    }
+
+    let now = Local::now();
+
+    let categories_tree = db.open_tree(category::NAME)?;
+    let sessions_tree = db.open_tree(session::NAME)?;
+
+    let categories: HashMap<category::K, category::V> = categories_tree
+        .iter()
+        .map(|result| {
+            result.map(|(k, v)| deserialize(&k).and_then(|k| deserialize(&v).map(|v| (k, v))))
+        })
+        .collect::<Result<Result<_, _>, _>>()??;
+
+    let sessions: HashMap<session::K, session::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 mut categories_stats: Vec<_> = categories
+        .into_iter()
+        .map(|(category_id, category)| {
+            let my_sessions = sessions
+                .values()
+                .filter(|session| session.category == category_id);
+
+            let last_session = my_sessions.clone().max_by_key(|session| &session.started);
+
+            let secs_last_session = sum_sessions(last_session);
+
+            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);
+
+            CategoryStatsContext {
+                category_id,
+                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(),
+            }
+        })
+        .collect();
+
+    categories_stats.sort_by(|a, b| a.category.name.cmp(&b.category.name));
+
+    let context = StatsContext { categories_stats };
+
+    Ok(Template::render("stats_all", &context))
+}
+
+fn compute_percentage_per_hour<'a, I>(sessions: I) -> BTreeMap<u32, f64>
+where
+    I: Iterator<Item = &'a session::V>,
+{
+    let mut stats_per_hour = BTreeMap::new();
+    for session in sessions {
+        let an_hour = chrono::Duration::minutes(60);
+
+        let hour_of = |time: DateTime<Local>| {
+            time.with_minute(0)
+                .and_then(|time| time.with_second(0))
+                .and_then(|time| time.with_nanosecond(0))
+                .unwrap()
+        };
+
+        let next_hour_of =
+            |time: DateTime<Local>| hour_of(time).checked_add_signed(an_hour).unwrap();
+
+        let mut add_hour_stats =
+            |time: DateTime<Local>, hours| *stats_per_hour.entry(time.hour()).or_default() += hours;
+
+        let mut hour = hour_of(session.started);
+        loop {
+            if hour_of(session.started) == hour {
+                let minutes_started = (session.started - hour).num_minutes() as u32;
+
+                if hour_of(session.ended) == hour {
+                    let minutes_ended = (session.ended - hour).num_minutes() as u32;
+                    let minutes_last_hour = minutes_ended - minutes_started;
+                    add_hour_stats(hour, minutes_last_hour as f64);
+
+                    break;
+                } else {
+                    let minutes_first_hour = 60 - minutes_started;
+                    add_hour_stats(hour, minutes_first_hour as f64);
+                }
+            } else if hour_of(session.ended) == hour {
+                let minutes_last_hour = (session.ended - hour).num_minutes() as u32;
+                add_hour_stats(hour, minutes_last_hour as f64);
+                break;
+            } else {
+                add_hour_stats(hour, 60.0);
+            }
+            hour = next_hour_of(hour);
+        }
+    }
+
+    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;
+    }
+
+    stats_per_hour
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+    use crate::database::latest::trees::sessions;
+    use chrono::{DateTime, Local};
+
+    #[test]
+    fn test_compute_percentage_per_hour() {
+        let today = Local::now();
+
+        let test_data = vec![
+            (
+                vec![((11, 20), (13, 20))],
+                vec![(11, 33.3), (12, 50.0), (13, 16.6)],
+            ),
+            (vec![((09, 00), (09, 01))], vec![(09, 100.0)]),
+            (vec![((09, 00), (09, 59))], vec![(09, 100.0)]),
+            (
+                vec![((13, 00), (16, 00))],
+                vec![(13, 33.3), (14, 33.3), (15, 33.3), (16, 0.0)],
+            ),
+        ];
+
+        for (sessions, expected) in test_data {
+            let sessions: Vec<_> = sessions
+                .into_iter()
+                .map(|((h1, m1), (h2, m2))| {
+                    let set_hm = |t: DateTime<Local>, h, m| {
+                        t.with_hour(h)
+                            .and_then(|t| t.with_minute(m))
+                            .and_then(|t| t.with_second(0))
+                            .and_then(|t| t.with_nanosecond(0))
+                            .unwrap()
+                    };
+
+                    session::V {
+                        category: Default::default(),
+                        deleted: false,
+                        started: set_hm(today, h1, m1),
+                        ended: set_hm(today, h2, m2),
+                    }
+                })
+                .collect();
+
+            let percentages = compute_percentage_per_hour(sessions.iter());
+            println!("{:#?}", percentages);
+            assert!(percentages.into_iter().eq(expected.into_iter()));
+        }
+    }
+}