wip 2

Cargo.toml

@@ -4,3 +4,5 @@ members = [
     "cli",
     "lib",
 ]
+
+resolver = "2"

cli/Cargo.toml

@@ -14,7 +14,7 @@ thiserror = "1.0.24"
 notify = "4.0.16"
 log = "0.4.14"
 pretty_env_logger = "0.4.0"
-uuid = { version = "0.8", features = ["serde", "v4"] }
+uuid = { version = "1.8.0", features = ["serde", "v4"] }
 chrono = { version = "0.4", features = ["serde"] }
 structopt = "0.3.21"
 syscalls = { version = "0.3", default-features = false }

lib/Cargo.toml

@@ -9,5 +9,5 @@ edition = "2021"
 [dependencies]
 chrono = { version = "0.4", features = ["serde"] }
 serde = { version = "1", features = ["derive"] }
-uuid = { version = "0.8", features = ["serde", "v4"] }
+uuid = { version = "1.8.0", features = ["serde", "v4"] }
 

lib/src/v2.rs

@@ -6,6 +6,7 @@ pub(self) use uuid::Uuid;
 pub mod global {}
 
 pub mod trees {
+    // ------- time tracking --------
     pub mod category {
         use super::super::*;
 
@@ -55,9 +56,43 @@ pub mod trees {
             /// The time when this session was ended
             pub ended: DateTime<Local>,
 
-            // FIXME: this field is currently not used
             /// Whether the item has been "deleted", e.g. it shoudn't be shown in the view
+            // FIXME: this field is currently not used
             pub deleted: bool,
         }
     }
+    // -------------------------------------
+
+    // ------- daily tasks tracking --------
+    pub mod daily {
+        use super::super::*;
+
+        pub const NAME: &str = "DAILIES";
+
+        pub type K = Uuid;
+
+        #[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, PartialOrd, Ord)]
+        pub struct V {
+            /// The name of the task.
+            pub name: String,
+
+            // Task should be done every <unit_count> <unit>s, e.g. every 3 days or every 1 week.
+            pub unit_count: u32,
+            pub unit: TimeUnit,
+
+            /// Whether the item has been "deleted", e.g. it shoudn't be shown in the view
+            // FIXME: this field is currently not used
+            #[serde(default)]
+            pub deleted: bool,
+        }
+
+        #[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, PartialOrd, Ord)]
+        pub enum TimeUnit {
+            Day,
+            Week,
+            Month,
+            Year,
+        }
+    }
+    // -------------------------------------
 }

server/Cargo.toml

@@ -15,23 +15,23 @@ futures = "0.3"
 chrono = { version = "0.4", features = ["serde"] }
 sled = "0.34"
 semver = "0.11"
-uuid = { version = "0.8", features = ["serde", "v4"] }
+uuid = { version = "1.8.0", features = ["serde", "v4"] }
 duplicate = "0.2"
 bincode = "1"
-handlebars = "3"
+handlebars = "4.1.0"
 itertools = "0.10.0"
 
 [dependencies.stl_lib]
 path = "../lib"
 
 [dependencies.tokio]
-version = "1"
+version = "1.37.0"
 features = ["sync", "time"]
 
 [dependencies.rocket]
-version = "0.5.0-rc.1"
+version = "0.5.0"
 features = ["secrets", "json", "uuid"]
 
 [dependencies.rocket_dyn_templates]
-version = "0.1.0-rc.1"
+version = "0.1.0"
 features = ["handlebars"]

server/example.env

@@ -9,7 +9,7 @@ DB_PATH=./database
 #ROCKET_PORT=8000
 #ROCKET_WORKERS=[number of cpus * 2]
 #ROCKET_LOG="normal"
-#ROCKET_SECRET_KEY=[randomly generated at launch]
+#ROCKET_SECRET_KEY=[random string, 44 or 88 for base64, 64 for hex]
 #ROCKET_LIMITS="{ forms = 32768 }"
 ROCKET_TEMPLATE_DIR="templates"
 ## =============================== ##

server/src/auth.rs

@@ -5,7 +5,7 @@ use rocket::{
     http::{Cookie, CookieJar, Status},
     post,
     request::{FromRequest, Outcome, Request},
-    response::{content::Html, Redirect},
+    response::{content::RawHtml, Redirect},
     uri, State,
 };
 use rocket_dyn_templates::Template;
@@ -17,6 +17,8 @@ impl From<String> for MasterPassword {
     }
 }
 
+const AUTH_QUERY_KEY: &str = "pw";
+
 const AUTH_COOKIE_KEY: &str = "authorized";
 const AUTH_COOKIE_VAL: &str = "true";
 
@@ -31,18 +33,46 @@ impl<'a> FromRequest<'a> for Authorized {
     type Error = Unauthorized;
 
     async fn from_request(request: &'a Request<'_>) -> Outcome<Self, Self::Error> {
+        // Check if user has been authorized by cookie
         let cookies = request.cookies();
-
         match cookies.get_private(AUTH_COOKIE_KEY) {
-            Some(cookie) if cookie.value() == AUTH_COOKIE_VAL => Outcome::Success(Authorized),
+            Some(cookie) if cookie.value() == AUTH_COOKIE_VAL => {
-            _ => Outcome::Failure((Status::Unauthorized, Unauthorized)),
+                return Outcome::Success(Authorized)
+            }
+            _ => {}
         }
+
+        request
+            .guard::<&State<MasterPassword>>()
+            .await
+            .map_error(|_| (Status::Unauthorized, Unauthorized))
+            .and_then(|master_pass| {
+                // Check if query string contains password
+                request
+                    .uri()
+                    .query()
+                    .iter()
+                    .inspect(|q| eprintln!("1 {q:?}"))
+                    .flat_map(|q| q.split('&'))
+                    .flat_map(|q| q.percent_decode())
+                    .inspect(|q| eprintln!("2 {q:?}"))
+                    .flat_map(|kv| {
+                        kv.split_once('=')
+                            .map(|(k, v)| (k.to_owned(), v.to_owned()))
+                    })
+                    .inspect(|q| eprintln!("3 {q:?}"))
+                    .filter(|(k, _)| k == AUTH_QUERY_KEY)
+                    .filter(|(_, v)| v == &master_pass.0)
+                    .map(|_| Outcome::Success(Authorized))
+                    .next()
+                    .unwrap_or(Outcome::Error((Status::Unauthorized, Unauthorized)))
+            })
     }
 }
 
 #[catch(401)]
-pub fn login_page(_req: &Request) -> Html<Template> {
+pub fn login_page(_req: &Request) -> RawHtml<Template> {
-    Html(Template::render("login", &()))
+    RawHtml(Template::render("login", &()))
 }
 
 #[derive(FromForm)]

server/src/database/migrations/v1_to_v2.rs

@@ -28,8 +28,8 @@ pub fn migrate(db: &mut Db) -> Result<(), MigrationError> {
             // Convert to new value
             let v2_value = v2::trees::session::V {
                 category,
-                started: DateTime::<Utc>::from_utc(started, Utc).into(),
+                started: DateTime::<Utc>::from_naive_utc_and_offset(started, Utc).into(),
-                ended: DateTime::<Utc>::from_utc(ended, Utc).into(),
+                ended: DateTime::<Utc>::from_naive_utc_and_offset(ended, Utc).into(),
                 deleted: false,
             };
 
@@ -63,7 +63,8 @@ pub fn migrate(db: &mut Db) -> Result<(), MigrationError> {
                 name,
                 description: None,
                 color,
-                started: started.map(|ndt| DateTime::<Utc>::from_utc(ndt, Utc).into()),
+                started: started
+                    .map(|ndt| DateTime::<Utc>::from_naive_utc_and_offset(ndt, Utc).into()),
                 parent: None,
                 deleted: false,
             };

server/src/database/v2.rs

@@ -57,4 +57,24 @@ pub mod trees {
                 .collect::<Result<Result<_, _>, _>>()??)
         }
     }
+
+    pub mod daily {
+        use super::super::*;
+        pub use stl_lib::v2::trees::daily::*;
+
+        pub fn get_all(tree: &sled::Tree) -> Result<HashMap<K, V>, StatusJson> {
+            Ok(tree
+                .iter()
+                .map(|result| {
+                    result
+                        .map(|(k, v)| deserialize(&k).and_then(|k| deserialize(&v).map(|v| (k, v))))
+                })
+                .collect::<Result<Result<_, _>, _>>()??)
+        }
+
+        pub fn put(tree: &sled::Tree, key: &K, val: &V) -> Result<(), StatusJson> {
+            tree.insert(serialize(key)?, serialize(val)?)?;
+            Ok(())
+        }
+    }
 }

server/src/main.rs

@@ -33,7 +33,9 @@ async fn main() -> io::Result<()> {
 
     let birth_date: BirthDate = env::var("BIRTH_DATE")
         .map(|s| BirthDate(s.parse().expect("failed to parse BIRTH_DATE")))
-        .unwrap_or_else(|_| BirthDate(NaiveDate::from_ymd(2000, 1, 1)));
+        .unwrap_or_else(|_| {
+            BirthDate(NaiveDate::from_ymd_opt(2000, 1, 1).expect("Date is correct"))
+        });
 
     let mut sled = sled::open(db_path)?;
     match sled.insert(
@@ -76,6 +78,8 @@ async fn main() -> io::Result<()> {
                 routes::pages::bump_session,
                 routes::pages::stats::single_stats,
                 routes::pages::stats::all_stats,
+                routes::pages::dailies::dailies,
+                routes::pages::dailies::new_daily,
                 routes::pages::weeks::weeks,
             ],
         )
@@ -89,10 +93,10 @@ async fn main() -> io::Result<()> {
                 routes::api::category::unarchive,
                 routes::api::category::remove_parent,
                 routes::api::category::set_parent,
-                routes::api::start_session,
+                routes::api::session::start_session,
-                routes::api::end_session,
+                routes::api::session::end_session,
-                routes::api::edit_session,
+                routes::api::session::edit_session,
-                routes::api::delete_session,
+                routes::api::session::delete_session,
                 routes::api::wait_for_event,
                 auth::login,
             ],

server/src/routes/api.rs

@@ -1,175 +1,12 @@
 pub mod category;
+pub mod session;
 
 use crate::auth::Authorized;
-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::serde::json::Json;
-use rocket::serde::uuid::Uuid;
+use rocket::{get, State};
-use rocket::{get, post, uri, State};
-use sled::Transactional;
 use stl_lib::wfe::WaitForEvent;
 
-#[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> {
-    use crate::database::latest::trees::{category, session};
-
-    let category_uuid_s = sled::IVec::from(serialize(&category_uuid)?);
-
-    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,
-                                    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> {
-    use crate::database::latest::trees::session;
-
-    let session_uuid_s = sled::IVec::from(serialize(&session_uuid)?);
-
-    let session = session::V {
-        category: session.category,
-        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> {
-    use crate::database::latest::trees::session;
-
-    let session_uuid_s = sled::IVec::from(serialize(&session_uuid)?);
-
-    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,

server/src/routes/api/session.rs

@@ -0,0 +1,167 @@
+use crate::auth::Authorized;
+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::serde::uuid::Uuid;
+use rocket::{post, uri, State};
+use sled::Transactional;
+
+#[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> {
+    use crate::database::latest::trees::{category, session};
+
+    let category_uuid_s = sled::IVec::from(serialize(&category_uuid)?);
+
+    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,
+                                    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> {
+    use crate::database::latest::trees::session;
+
+    let session_uuid_s = sled::IVec::from(serialize(&session_uuid)?);
+
+    let session = session::V {
+        category: session.category,
+        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> {
+    use crate::database::latest::trees::session;
+
+    let session_uuid_s = sled::IVec::from(serialize(&session_uuid)?);
+
+    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))))
+    // })??)
+}

server/src/routes/pages.rs

@@ -1,13 +1,15 @@
+pub mod dailies;
 pub mod stats;
 pub mod weeks;
 
 use crate::auth::Authorized;
 use crate::database::latest::trees::{category, session};
+use crate::routes::api;
 use crate::status_json::StatusJson;
 use crate::util::EventNotifier;
 use bincode::{deserialize, serialize};
 use rocket::http::Status;
-use rocket::response::content::Html;
+use rocket::response::content::RawHtml;
 use rocket::response::Redirect;
 use rocket::serde::uuid::Uuid;
 use rocket::{get, post, uri, State};
@@ -17,7 +19,7 @@ use std::collections::{BTreeMap, HashMap};
 use std::time::Duration;
 
 #[get("/")]
-pub fn index(_auth: Authorized, db: &State<sled::Db>) -> Result<Html<Template>, StatusJson> {
+pub fn index(_auth: Authorized, db: &State<sled::Db>) -> Result<RawHtml<Template>, StatusJson> {
     #[derive(Debug, Serialize, Deserialize, PartialOrd, Ord, PartialEq, Eq)]
     struct Node {
         category: category::V,
@@ -90,7 +92,7 @@ pub fn index(_auth: Authorized, db: &State<sled::Db>) -> Result<Html<Template>,
         categories: top_level_nodes,
     };
 
-    Ok(Html(Template::render("index", &context)))
+    Ok(RawHtml(Template::render("index", &context)))
 }
 
 #[post("/category/<category_uuid>/start_session")]
@@ -100,7 +102,7 @@ pub fn start_session(
     event_notifier: &State<EventNotifier>,
     db: &State<sled::Db>,
 ) -> Result<Redirect, StatusJson> {
-    super::api::toggle_category_session(category_uuid, true, event_notifier, db)?;
+    api::session::toggle_category_session(category_uuid, true, event_notifier, db)?;
     Ok(Redirect::to(uri!(index)))
 }
 
@@ -111,7 +113,7 @@ pub fn end_session(
     event_notifier: &State<EventNotifier>,
     db: &State<sled::Db>,
 ) -> Result<Redirect, StatusJson> {
-    super::api::toggle_category_session(category_uuid, false, event_notifier, db)?;
+    api::session::toggle_category_session(category_uuid, false, event_notifier, db)?;
     Ok(Redirect::to(uri!(index)))
 }
 
@@ -164,7 +166,7 @@ pub fn session_edit(
     _auth: Authorized,
     session_uuid: Uuid,
     db: &State<sled::Db>,
-) -> Result<Html<Template>, StatusJson> {
+) -> Result<RawHtml<Template>, StatusJson> {
     #[derive(Debug, Serialize, Deserialize)]
     struct SessionPageContext {
         session: session::V,
@@ -182,13 +184,13 @@ pub fn session_edit(
                 session_id: session_uuid,
             };
 
-            Ok(Html(Template::render("edit_session", &context)))
+            Ok(RawHtml(Template::render("edit_session", &context)))
         }
     }
 }
 
 #[get("/history")]
-pub fn history(_auth: Authorized, db: &State<sled::Db>) -> Result<Html<Template>, StatusJson> {
+pub fn history(_auth: Authorized, db: &State<sled::Db>) -> Result<RawHtml<Template>, StatusJson> {
     #[derive(Debug, Serialize, Deserialize)]
     struct HistoryEntryContext {
         category: category::V,
@@ -235,5 +237,5 @@ pub fn history(_auth: Authorized, db: &State<sled::Db>) -> Result<Html<Template>
     context.entries.sort_by_key(|entry| entry.session.started);
     context.entries.reverse();
 
-    Ok(Html(Template::render("history", &context)))
+    Ok(RawHtml(Template::render("history", &context)))
 }

server/src/routes/pages/dailies.rs

@@ -0,0 +1,58 @@
+use rocket::{
+    form::Form,
+    get, post,
+    response::{content::RawHtml, Redirect},
+    uri, FromForm, State,
+};
+use rocket_dyn_templates::Template;
+use serde::{Deserialize, Serialize};
+use uuid::Uuid;
+
+use crate::{
+    auth::Authorized,
+    database::latest::trees::daily::{self, V as Daily},
+    status_json::StatusJson,
+};
+
+#[derive(FromForm)]
+pub struct NewDaily {
+    name: String,
+    unit: String,
+    unit_count: u32,
+}
+
+#[post("/dailies/new", data = "<daily>")]
+pub fn new_daily(
+    _auth: Authorized,
+    db: &State<sled::Db>,
+    daily: Form<NewDaily>,
+) -> Result<Redirect, StatusJson> {
+    let daily = daily.into_inner();
+    let daily = Daily {
+        name: daily.name,
+        unit: serde_json::from_str(&format!("\"{}\"", daily.unit)).unwrap(), // TODO
+        unit_count: daily.unit_count,
+        deleted: false,
+    };
+
+    let dailies_tree = db.open_tree(daily::NAME)?;
+    daily::put(&dailies_tree, &Uuid::new_v4(), &daily)?;
+
+    Ok(Redirect::to(uri!(dailies)))
+}
+
+#[get("/dailies")]
+pub fn dailies(_auth: Authorized, db: &State<sled::Db>) -> Result<RawHtml<Template>, StatusJson> {
+    #[derive(Default, Debug, Serialize, Deserialize)]
+    struct TemplateContext {
+        dailies: Vec<Daily>,
+    }
+
+    let dailies_tree = db.open_tree(daily::NAME)?;
+    let mut ctx = TemplateContext::default();
+
+    ctx.dailies = daily::get_all(&dailies_tree)?.into_values().collect();
+    ctx.dailies.sort_by(|a, b| a.name.cmp(&b.name));
+
+    Ok(RawHtml(Template::render("dailies", &ctx)))
+}

server/src/routes/pages/stats.rs

@@ -2,9 +2,9 @@ use crate::auth::Authorized;
 use crate::database::latest::trees::{category, session};
 use crate::status_json::StatusJson;
 use crate::util::OrdL;
-use chrono::{Date, DateTime, Datelike, Duration, Local, Timelike};
+use chrono::{DateTime, Datelike, Duration, Local, NaiveDate, Timelike};
 use itertools::Itertools;
-use rocket::{get, http::Status, response::content::Html, serde::uuid::Uuid, State};
+use rocket::{get, http::Status, response::content::RawHtml, serde::uuid::Uuid, State};
 use rocket_dyn_templates::Template;
 use serde::{Deserialize, Serialize};
 use std::collections::{BTreeMap, HashMap, HashSet};
@@ -141,7 +141,7 @@ pub fn single_stats(
     _auth: Authorized,
     category_id: Uuid,
     db: &State<sled::Db>,
-) -> Result<Html<Template>, StatusJson> {
+) -> Result<RawHtml<Template>, StatusJson> {
     let categories_tree = db.open_tree(category::NAME)?;
     let sessions_tree = db.open_tree(session::NAME)?;
 
@@ -153,11 +153,11 @@ pub fn single_stats(
 
     let now = Local::now();
     let ctx = category_stats_ctx(now, category_id, category, &sessions, &child_map);
-    Ok(Html(Template::render("stats_single", dbg!(&ctx))))
+    Ok(RawHtml(Template::render("stats_single", dbg!(&ctx))))
 }
 
 #[get("/stats")]
-pub fn all_stats(_auth: Authorized, db: &State<sled::Db>) -> Result<Html<Template>, StatusJson> {
+pub fn all_stats(_auth: Authorized, db: &State<sled::Db>) -> Result<RawHtml<Template>, StatusJson> {
     #[derive(Debug, Serialize, Deserialize)]
     struct StatsContext {
         categories_stats: Vec<CategoryStatsCtx>,
@@ -185,15 +185,11 @@ pub fn all_stats(_auth: Authorized, db: &State<sled::Db>) -> Result<Html<Templat
 
     let context = StatsContext { categories_stats };
 
-    Ok(Html(Template::render("stats_all", &context)))
+    Ok(RawHtml(Template::render("stats_all", &context)))
 }
 
-/// Compute the duration of `day` that is covered by the span `start..end`
+/// Compute the subset of `day` that is covered by the span `start..end`
-fn span_duration_of_day(
+fn span_duration_of_day(start: DateTime<Local>, end: DateTime<Local>, day: NaiveDate) -> Duration {
-    start: DateTime<Local>,
-    end: DateTime<Local>,
-    day: Date<Local>,
-) -> Duration {
     if end < start {
         panic!("start must come before end");
     }
@@ -201,26 +197,29 @@ fn span_duration_of_day(
     // if the span is 0
     // or if the day is not in the span
     // the duration is zero
-    if end == start || start.date() > day || end.date() < day {
+    if end == start || start.date_naive() > day || end.date_naive() < day {
         return Duration::zero();
     }
 
-    if start.date() < day {
+    // TODO: deal with unwrap
-        if end.date() > day {
+    let day_start = day.and_hms_opt(0, 0, 0).unwrap().and_local_timezone(Local).unwrap();
+
+    if start.date_naive() < day {
+        if end.date_naive() > day {
             Duration::days(1)
         } else {
-            debug_assert_eq!(end.date(), day);
+            debug_assert_eq!(end.date_naive(), day);
 
-            end - day.and_hms(0, 0, 0)
+            end - day_start
         }
-    } else if end.date() > day {
+    } else if end.date_naive() > day {
-        debug_assert_eq!(start.date(), day);
+        debug_assert_eq!(start.date_naive(), day);
 
-        day.and_hms(0, 0, 0) + Duration::days(1) - start
+        day_start + Duration::days(1) - start
     } else {
         debug_assert!(start < end);
-        debug_assert_eq!(start.date(), day);
+        debug_assert_eq!(start.date_naive(), day);
-        debug_assert_eq!(end.date(), day);
+        debug_assert_eq!(end.date_naive(), day);
 
         end - start
     }
@@ -307,14 +306,14 @@ where
 {
     const NUM_WEEKS: usize = 12;
 
-    let today = Local::today();
+    let today = Local::now().date_naive();
     let last_day = today
         // take at least NUM_WEEKS * 7 days
         - Duration::weeks(NUM_WEEKS as i64)
         // round up to nearest monday
         - Duration::days(today.weekday().num_days_from_monday() as i64);
 
-    let mut days: BTreeMap<Date<Local>, Duration> = Default::default();
+    let mut days: BTreeMap<NaiveDate, Duration> = Default::default();
 
     // calculate the time spent logging this category for every day of the last NUM_WEEKS
     for session in sessions {
@@ -350,8 +349,8 @@ where
 
                     let month = day.month();
 
-                    let month_border = |other_day: Date<_>| other_day.month() != month;
+                    let month_border = |other_day: NaiveDate| other_day.month() != month;
-                    let month_or_week_border = |other_day: Date<_>| {
+                    let month_or_week_border = |other_day: NaiveDate| {
                         other_day.iso_week() != week || month_border(other_day)
                     };
 

server/src/routes/pages/weeks.rs

@@ -2,7 +2,7 @@ use crate::auth::Authorized;
 use crate::status_json::StatusJson;
 use chrono::{Duration, Local, NaiveDate};
 use itertools::Itertools;
-use rocket::{get, response::content::Html, State};
+use rocket::{get, response::content::RawHtml, State};
 use rocket_dyn_templates::Template;
 use serde::{Deserialize, Serialize};
 use std::borrow::Cow;
@@ -14,7 +14,7 @@ pub struct BirthDate(pub NaiveDate);
 pub fn weeks(
     _auth: Authorized,
     birth_date: &State<BirthDate>,
-) -> Result<Html<Template>, StatusJson> {
+) -> Result<RawHtml<Template>, StatusJson> {
     type Color<'a> = Cow<'a, str>;
 
     #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
@@ -57,10 +57,10 @@ pub fn weeks(
         periods: Vec<PeriodCtx<'a>>,
     }
 
-    let now = Local::now().date();
+    let now = Local::now().date_naive();
     let birth_date = birth_date.0;
 
-    let lived: Duration = now.naive_local() - birth_date;
+    let lived: Duration = now - birth_date;
     let one_year = Duration::days(365);
 
     let life_expectancy = (one_year * 81).num_weeks();
@@ -108,5 +108,5 @@ pub fn weeks(
             .collect(),
     };
 
-    Ok(Html(Template::render("weeks", &context)))
+    Ok(RawHtml(Template::render("weeks", &context)))
 }

server/static/styles/common.css

@@ -233,6 +233,88 @@ ul.striped_list > li:nth-child(odd) ul li:nth-child(odd)  { background-color:#30
     display: none;
 }
 
+.dailies_list {
+	max-width: 40rem;
+	margin: auto;
+	display: flex;
+	flex-direction: column;
+}
+
+.dailies_entry {
+	color: wheat;
+	font-size: 1.5em;
+	background: #3a3743;
+	margin-bottom: 1rem;
+	padding: 1rem;
+	border-radius: 0.35rem;
+	border: .2rem solid #45374f;
+	display: flex;
+	cursor: pointer;
+
+	transition: background-color 0.1s;
+}
+
+.dailies_entry:hover {
+	background-color: #4c4858;
+}
+
+.dailies_entry:active {
+	background-color: #312e38;
+}
+
+.dailies_entry > span {
+	flex-grow: 1
+}
+
+.dailies_checkbox input[type=checkbox] {
+  visibility:hidden;
+  display:none
+}
+.dailies_checkbox *,
+.dailies_checkbox :after,
+.dailies_checkbox :before {
+  box-sizing:border-box
+}
+.dailies_checkbox .container {
+  cursor:pointer;
+  user-select:none;
+  font-size:25px;
+  display:block;
+  position:relative
+}
+.dailies_checkbox .checkmark {
+  --spread:10px;
+  background:#000;
+  border-radius:50px;
+  width:1.3em;
+  height:1.3em;
+  transition:all .7s;
+  position:relative;
+  top:0;
+  left:0
+}
+.dailies_checkbox .container input:checked~.checkmark {
+  box-shadow:-5px -5px var(--spread)0px #5b51d8,0 -5px var(--spread)0px #833ab4,5px -5px var(--spread)0px #e1306c,5px 0 var(--spread)0px #fd1d1d,5px 5px var(--spread)0px #f77737,0 5px var(--spread)0px #fcaf45,-5px 5px var(--spread)0px #ffdc80;
+  background:#000
+}
+.dailies_checkbox .checkmark:after {
+  content:"";
+  display:none;
+  position:absolute
+}
+.dailies_checkbox .container input:checked~.checkmark:after {
+  display:block
+}
+.dailies_checkbox .container .checkmark:after {
+  border:.15em solid wheat;
+  border-width:0 .15em .15em 0;
+  width:.25em;
+  height:.5em;
+  top:.34em;
+  left:.5em;
+  transform:rotate(45deg)
+}
+
 .life_calendar {
 	display: flex;
 	flex-direction: row;

server/templates/dailies.hbs

@@ -0,0 +1,14 @@
+<!DOCTYPE html>
+<html lang="en">
+	{{> head}}
+	<body>
+		{{> header}}
+		<h1>Dailies</h2>
+
+		<div class="category_list">
+		{{#each categories}}
+		{{>category_entry}}
+        {{/each}}
+		</div>
+	</body>
+</html>

server/templates/dailies.html.hbs

@@ -0,0 +1,37 @@
+<!DOCTYPE html>
+<html lang="en">
+	{{> head}}
+	<body>
+		{{> header}}
+
+		<div class="striped_list dailies_list">
+			<h1>Dailies</h2>
+			{{#each dailies}}
+			<button class="dailies_entry">
+				<div class="dailies_checkbox"><label class="container"><input type="checkbox"><div class="checkmark"></div></label></div>
+				<span>
+					{{this.name}}
+					<span>1 gång per</span>
+					{{this.unit_count}}
+					{{this.unit}}
+				</span>
+			</button>
+			{{/each}}
+
+			<form action="/dailies/new" method="post">
+				<span>Namn</span>
+				<input type="text" name="name"></input>
+				<span>1 gång per</span>
+				<input type="number" name="unit_count"></input>
+				<select name="unit">
+				  <option value="Day">Dag</option>
+				  <option value="Week">Vecka</option>
+				  <option value="Month">Månad</option>
+				  <option value="Year">År</option>
+				</select>
+				<br>
+				<button type="submit">spara</button>
+			</form>
+		</div>
+	</body>
+</html>