fix: improve statusbar and use the user's timezone

ImShyMike · ImShyMike · commit 5a22b9b9f95c · 2026-01-24T20:20:01.000Z
diff --git a/rustytime/src/handlers/api/user.rs b/rustytime/src/handlers/api/user.rs
@@ -1,12 +1,14 @@
 use aide::NoApi;
+use axum::Json;
 use axum::extract::ConnectInfo;
-use axum::extract::{Json, Path, State};
+use axum::extract::{Path, State};
 use axum::http::StatusCode;
 use axum::response::{IntoResponse, Response};
 use chrono::Utc;
 use diesel::prelude::*;
 use ipnetwork::IpNetwork;
-use serde_json::json;
+use schemars::JsonSchema;
+use serde::Serialize;
 use std::net::IpAddr;
 use std::net::SocketAddr;
 
@@ -16,15 +18,47 @@ use crate::models::heartbeat::*;
 use crate::models::project::get_or_create_project_id;
 use crate::schema::heartbeats;
 use crate::state::AppState;
-use crate::utils::auth::{get_user_id_from_api_key, get_valid_api_key};
+use crate::utils::auth::{get_user_from_api_key, get_user_id_from_api_key, get_valid_api_key};
 use crate::utils::extractors::DbConnection;
 use crate::utils::http::extract_client_ip_from_headers;
-use crate::utils::time::{TimeFormat, human_readable_duration};
+use crate::utils::time::{
+    TimeFormat, get_day_end_utc, get_day_start_utc, get_today_in_timezone, human_readable_duration,
+    parse_timezone,
+};
 use std::collections::{HashMap, hash_map};
 
 const MAX_HEARTBEATS_PER_REQUEST: usize = 100;
 const HEARTBEAT_INSERT_BATCH_SIZE: usize = 1_000; // avoids hitting Postgres' 65k parameter limit
 
+#[derive(Serialize, JsonSchema)]
+pub struct StatusBarResponse {
+    data: StatusBarResponseData,
+}
+
+#[derive(Serialize, JsonSchema)]
+pub struct StatusBarResponseData {
+    grand_total: StatusBarResponseDataGrandTotal,
+    range: StatusBarResponseDataRange,
+}
+
+#[derive(Serialize, JsonSchema)]
+pub struct StatusBarResponseDataGrandTotal {
+    decimal: String,
+    digital: String,
+    hours: i64,
+    minutes: i64,
+    human_readable: String,
+    total_seconds: i64,
+}
+
+#[derive(Serialize, JsonSchema)]
+pub struct StatusBarResponseDataRange {
+    date: String,
+    end: String,
+    start: String,
+    timezone: String,
+}
+
 /// Process heartbeat request and store in the database
 async fn process_heartbeat_request(
     app_state: &AppState,
@@ -132,14 +166,15 @@ pub async fn create_heartbeats(
 /// Handler to get today's status bar data
 pub async fn get_statusbar_today(
     State(app_state): State<AppState>,
-    Path(id): Path<String>,
     NoApi(DbConnection(mut conn)): NoApi<DbConnection>,
+    Path(id): Path<String>,
     headers: axum::http::HeaderMap,
     uri: axum::http::Uri,
-) -> Result<Json<serde_json::Value>, Response> {
-    let user_id: i32 = if id != "current" {
+) -> Result<Json<StatusBarResponse>, Response> {
+    let (user_id, timezone) = if id != "current" {
+        // not implemented
         match id.parse::<i32>() {
-            Ok(id) => id,
+            Ok(id) => (id, None),
             Err(_) => return Err((StatusCode::BAD_REQUEST, "Bad request").into_response()),
         }
     } else {
@@ -149,22 +184,20 @@ pub async fn get_statusbar_today(
             None => return Err((StatusCode::BAD_REQUEST, "Bad request").into_response()),
         };
 
-        let user_result = get_user_id_from_api_key(&app_state.db_pool, &api_key).await;
-        match user_result {
-            Some(id) => id,
+        let user_result = get_user_from_api_key(&app_state.db_pool, &api_key).await;
+        let user = match user_result {
+            Some(user) => user,
             None => return Err((StatusCode::BAD_REQUEST, "Bad request").into_response()),
-        }
+        };
+
+        (user.id, Some(user.timezone))
     };
 
-    // calculate today's date range
-    let today = Utc::now().date_naive();
-    let start_of_day = today.and_hms_opt(0, 0, 0).unwrap().and_utc();
-    let end_of_day = today
-        .succ_opt()
-        .unwrap_or(today)
-        .and_hms_opt(0, 0, 0)
-        .unwrap()
-        .and_utc();
+    // calculate today's date range in user's timezone
+    let user_tz = parse_timezone(timezone.as_deref().unwrap_or("UTC"));
+    let today = get_today_in_timezone(user_tz);
+    let start_of_day = get_day_start_utc(today, user_tz);
+    let end_of_day = get_day_end_utc(today, user_tz);
 
     match Heartbeat::get_user_duration_seconds(
         &mut conn,
@@ -181,18 +214,24 @@ pub async fn get_statusbar_today(
         Ok(total_seconds) => {
             let time_obj = human_readable_duration(total_seconds, TimeFormat::HourMinute);
 
-            Ok(Json(json!({
-                "data": {
-                    "grand_total": {
-                        "decimal": format!("{:.2}", total_seconds as f64 / 3600.0),
-                        "digital": format!("{:02}:{:02}", time_obj.hours, time_obj.minutes),
-                        "hours": time_obj.hours,
-                        "minutes": time_obj.minutes,
-                        "text": time_obj.human_readable,
-                        "total_seconds": total_seconds
-                    }
-                }
-            })))
+            Ok(Json(StatusBarResponse {
+                data: StatusBarResponseData {
+                    grand_total: StatusBarResponseDataGrandTotal {
+                        decimal: format!("{:.2}", total_seconds as f64 / 3600.0),
+                        digital: format!("{:02}:{:02}", time_obj.hours, time_obj.minutes),
+                        hours: time_obj.hours,
+                        minutes: time_obj.minutes,
+                        human_readable: time_obj.human_readable,
+                        total_seconds,
+                    },
+                    range: StatusBarResponseDataRange {
+                        date: today.format("%Y-%m-%d").to_string(),
+                        start: start_of_day.to_rfc3339(),
+                        end: end_of_day.to_rfc3339(),
+                        timezone: timezone.unwrap_or_else(|| "UTC".to_string()),
+                    },
+                },
+            }))
         }
         Err(err) => {
             eprintln!("❌ Error calculating duration: {}", err);
diff --git a/rustytime/src/models/heartbeat/mod.rs b/rustytime/src/models/heartbeat/mod.rs
@@ -1,5 +1,5 @@
 use axum::http::HeaderMap;
-use chrono::{DateTime, Datelike, NaiveDate, NaiveDateTime, TimeZone, Utc};
+use chrono::{DateTime, Utc};
 use chrono_tz::Tz;
 use diesel::dsl::sql;
 use diesel::prelude::*;
@@ -12,7 +12,10 @@ use std::fmt;
 
 use crate::schema::heartbeats::{self};
 use crate::utils::http::parse_user_agent;
-use crate::utils::time::{TimeFormat, human_readable_duration};
+use crate::utils::time::{
+    TimeFormat, get_day_start_utc, get_month_start_date, get_week_start_date,
+    human_readable_duration, parse_timezone,
+};
 
 diesel::define_sql_function! {
     /// Calculate user duration with filters
@@ -858,7 +861,7 @@ impl Heartbeat {
         range: TimeRange,
         user_timezone: &str,
     ) -> QueryResult<i64> {
-        let tz: Tz = user_timezone.parse().unwrap_or(chrono_tz::UTC);
+        let tz = parse_timezone(user_timezone);
         let now = Utc::now();
 
         match Self::start_boundary_utc(range, tz, now) {
@@ -897,40 +900,16 @@ impl Heartbeat {
             return None;
         }
 
-        let now_local = now_utc.with_timezone(&tz);
+        let today = now_utc.with_timezone(&tz).date_naive();
 
-        let start_local_naive: NaiveDateTime = match range {
-            TimeRange::Day => {
-                // Today
-                now_local.date_naive().and_hms_opt(0, 0, 0).unwrap()
-            }
-            TimeRange::Week => {
-                // This week
-                let days_from_monday = now_local.weekday().num_days_from_monday() as i64;
-                let week_start_date =
-                    now_local.date_naive() - chrono::Duration::days(days_from_monday);
-                week_start_date.and_hms_opt(0, 0, 0).unwrap()
-            }
-            TimeRange::Month => {
-                // This month
-                let y = now_local.year();
-                let m = now_local.month();
-                NaiveDate::from_ymd_opt(y, m, 1)
-                    .unwrap()
-                    .and_hms_opt(0, 0, 0)
-                    .unwrap()
-            }
+        let start_date = match range {
+            TimeRange::Day => today,
+            TimeRange::Week => get_week_start_date(today),
+            TimeRange::Month => get_month_start_date(today),
             TimeRange::All => unreachable!(),
         };
 
-        // timezones are weird
-        let start_local = tz
-            .from_local_datetime(&start_local_naive)
-            .earliest()
-            .or_else(|| tz.from_local_datetime(&start_local_naive).latest())
-            .unwrap_or(now_local);
-
-        Some(start_local.with_timezone(&Utc))
+        Some(get_day_start_utc(start_date, tz))
     }
 
     /// Get dashboard stats filtered by time range (day, week, month, all)
@@ -940,7 +919,7 @@ impl Heartbeat {
         range: TimeRange,
         user_timezone: &str,
     ) -> QueryResult<DashboardStats> {
-        let tz: Tz = user_timezone.parse().unwrap_or(chrono_tz::UTC);
+        let tz = parse_timezone(user_timezone);
         let now = Utc::now();
 
         let filtered_rows: Vec<DashboardMetricRow> = match Self::start_boundary_utc(range, tz, now)
diff --git a/rustytime/src/utils/auth/mod.rs b/rustytime/src/utils/auth/mod.rs
@@ -4,6 +4,7 @@ use diesel::prelude::*;
 use serde::Deserialize;
 
 use crate::db::connection::DbPool;
+use crate::models::user::User;
 use crate::schema::users::dsl;
 
 /// Try to get API key from the "Authorization" header
@@ -74,5 +75,16 @@ pub async fn get_user_id_from_api_key(pool: &DbPool, api_key_value: &str) -> Opt
     Some(user_id)
 }
 
+/// Get user from the API key
+pub async fn get_user_from_api_key(pool: &DbPool, api_key_value: &str) -> Option<User> {
+    let api_key_uuid = uuid::Uuid::parse_str(api_key_value).ok()?;
+    let mut conn = pool.get().ok()?;
+    let user: User = dsl::users
+        .filter(dsl::api_key.eq(api_key_uuid))
+        .first(&mut conn)
+        .ok()?;
+    Some(user)
+}
+
 #[cfg(test)]
 mod tests;
diff --git a/rustytime/src/utils/time/mod.rs b/rustytime/src/utils/time/mod.rs
@@ -1,4 +1,7 @@
-use chrono::{DateTime, Datelike, Duration, NaiveDate, SecondsFormat, Utc};
+use chrono::{
+    DateTime, Datelike, Duration, NaiveDate, NaiveDateTime, SecondsFormat, TimeZone, Utc,
+};
+use chrono_tz::Tz;
 
 #[allow(dead_code)]
 #[derive(Debug)]
@@ -138,5 +141,49 @@ pub fn get_week_start(date: NaiveDate) -> NaiveDate {
     date - chrono::Duration::days(weekday as i64)
 }
 
+/// Parse a timezone string, returning the Tz or UTC as fallback
+#[inline(always)]
+pub fn parse_timezone(tz_str: &str) -> Tz {
+    tz_str.parse().unwrap_or(chrono_tz::UTC)
+}
+
+/// Convert a naive datetime in a timezone to UTC, handling DST transitions
+pub fn local_datetime_to_utc(naive_dt: NaiveDateTime, tz: Tz) -> DateTime<Utc> {
+    tz.from_local_datetime(&naive_dt)
+        .earliest()
+        .or_else(|| tz.from_local_datetime(&naive_dt).latest())
+        .map(|dt| dt.with_timezone(&Utc))
+        .unwrap_or_else(Utc::now)
+}
+
+/// Get the start of day (00:00:00) in the user's timezone, converted to UTC
+pub fn get_day_start_utc(date: NaiveDate, tz: Tz) -> DateTime<Utc> {
+    let naive_dt = date.and_hms_opt(0, 0, 0).unwrap();
+    local_datetime_to_utc(naive_dt, tz)
+}
+
+/// Get the end of day (start of next day) in the user's timezone, converted to UTC
+pub fn get_day_end_utc(date: NaiveDate, tz: Tz) -> DateTime<Utc> {
+    let tomorrow = date.succ_opt().unwrap_or(date);
+    let naive_dt = tomorrow.and_hms_opt(0, 0, 0).unwrap();
+    local_datetime_to_utc(naive_dt, tz)
+}
+
+/// Get today's date in the user's timezone
+pub fn get_today_in_timezone(tz: Tz) -> NaiveDate {
+    Utc::now().with_timezone(&tz).date_naive()
+}
+
+/// Get the start of the week (Monday) for a given date
+pub fn get_week_start_date(date: NaiveDate) -> NaiveDate {
+    let days_from_monday = date.weekday().num_days_from_monday() as i64;
+    date - chrono::Duration::days(days_from_monday)
+}
+
+/// Get the start of the month for a given date
+pub fn get_month_start_date(date: NaiveDate) -> NaiveDate {
+    NaiveDate::from_ymd_opt(date.year(), date.month(), 1).unwrap()
+}
+
 #[cfg(test)]
 mod tests;
