Add cli & lib crates

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))
+}