+
{/* Controls Bar */}
@@ -362,6 +383,7 @@ function TimeTrackingPage() {
timeEntries={filteredTimeEntries}
absenceEntries={filteredAbsences}
dateRange={dateRange}
+ focusedDay={focusedDay}
/>
) : (
+ {
+ self.send_json(Method::POST, "event/approve", Some(body))
+ .await
+ }
+
+ /// Answers success even for days it refuses to unlock, so read the
+ /// statuses back to see which days opened.
+ pub async fn unlock_events(&self, body: &KleerEventPeriod) -> Result {
+ self.send_json(Method::POST, "event/unlock", Some(body))
+ .await
+ }
+
pub async fn create_event(
&self,
body: &KleerEventWritable,
diff --git a/kleer/src/types.rs b/kleer/src/types.rs
index b76cbfc5..80cb6b06 100644
--- a/kleer/src/types.rs
+++ b/kleer/src/types.rs
@@ -279,6 +279,17 @@ pub struct KleerEventWritable {
pub internal_comment: Option,
}
+/// A user's time over one calendar month, the longest range Kleer locks at once.
+#[derive(Debug, Clone, PartialEq, Eq, Serialize)]
+#[serde(rename_all = "kebab-case")]
+pub struct KleerEventPeriod {
+ pub user_id: KleerIdRef,
+ #[serde(with = "date_format")]
+ pub start_date: Date,
+ #[serde(with = "date_format")]
+ pub end_date: Date,
+}
+
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct KleerSavedId {
pub id: i64,
diff --git a/toki-api/src/adapters/outbound/kleer/mod.rs b/toki-api/src/adapters/outbound/kleer/mod.rs
index 442b0096..45cac0de 100644
--- a/toki-api/src/adapters/outbound/kleer/mod.rs
+++ b/toki-api/src/adapters/outbound/kleer/mod.rs
@@ -9,7 +9,7 @@ use std::{
use async_trait::async_trait;
use kleer::{
KleerActivityList, KleerActivityReadable, KleerClient, KleerClientProjectList,
- KleerClientProjectReadable, KleerCredentials, KleerError, KleerEventReadable,
+ KleerClientProjectReadable, KleerCredentials, KleerError, KleerEventPeriod, KleerEventReadable,
KleerEventRestrictionList, KleerEventWritable, KleerIdRef,
};
use moka::future::Cache;
@@ -538,6 +538,19 @@ impl KleerAdapter {
Ok(())
}
+ fn month_periods(&self, date_range: (Date, Date)) -> Vec {
+ month_ranges(date_range)
+ .into_iter()
+ .map(|(start_date, end_date)| KleerEventPeriod {
+ user_id: KleerIdRef {
+ id: self.target_user_id,
+ },
+ start_date,
+ end_date,
+ })
+ .collect()
+ }
+
fn to_domain_day_statuses(statuses: KleerEventRestrictionList) -> Vec {
statuses
.event_restriction_readables
@@ -828,6 +841,26 @@ impl TimeTrackingClient for KleerAdapter {
Ok(Self::to_domain_day_statuses(statuses))
}
+ async fn lock_time_entries(&self, date_range: (Date, Date)) -> Result<(), TimeTrackingError> {
+ for period in self.month_periods(date_range) {
+ self.client
+ .approve_events(&period)
+ .await
+ .map_err(map_kleer_error)?;
+ }
+ Ok(())
+ }
+
+ async fn unlock_time_entries(&self, date_range: (Date, Date)) -> Result<(), TimeTrackingError> {
+ for period in self.month_periods(date_range) {
+ self.client
+ .unlock_events(&period)
+ .await
+ .map_err(map_kleer_error)?;
+ }
+ Ok(())
+ }
+
async fn create_time_entry(
&self,
request: &CreateTimeEntryRequest,
@@ -1031,6 +1064,27 @@ impl TimeTrackingClient for KleerAdapter {
}
}
+/// Kleer refuses to lock or unlock a range that crosses a month end.
+fn month_ranges((from, to): (Date, Date)) -> Vec<(Date, Date)> {
+ let mut ranges = Vec::new();
+ let mut start = from;
+
+ while start <= to {
+ let last_of_month = start
+ .replace_day(start.month().length(start.year()))
+ .expect("a month's length is a valid day of it");
+ let end = last_of_month.min(to);
+ ranges.push((start, end));
+
+ match end.next_day() {
+ Some(next) => start = next,
+ None => break,
+ }
+ }
+
+ ranges
+}
+
fn map_kleer_error(error: KleerError) -> TimeTrackingError {
match error {
KleerError::NotFound => TimeTrackingError::TimerNotFound,
@@ -1158,6 +1212,24 @@ mod tests {
const TARGET_USER_ID: i64 = 987;
+ #[test]
+ fn month_ranges_split_at_every_month_end() {
+ let date = |month, day| Date::from_calendar_date(2026, month, day).unwrap();
+
+ assert_eq!(
+ month_ranges((date(Month::October, 26), date(Month::October, 31))),
+ [(date(Month::October, 26), date(Month::October, 31))]
+ );
+ assert_eq!(
+ month_ranges((date(Month::September, 28), date(Month::November, 1))),
+ [
+ (date(Month::September, 28), date(Month::September, 30)),
+ (date(Month::October, 1), date(Month::October, 31)),
+ (date(Month::November, 1), date(Month::November, 1)),
+ ]
+ );
+ }
+
fn activity_assignment(activity_id: i64) -> KleerProjectActivityAssignment {
KleerProjectActivityAssignment {
activity: KleerIdRef { id: activity_id },
diff --git a/toki-api/src/domain/ports/inbound/time_tracking.rs b/toki-api/src/domain/ports/inbound/time_tracking.rs
index d8e84a54..5bb23e63 100644
--- a/toki-api/src/domain/ports/inbound/time_tracking.rs
+++ b/toki-api/src/domain/ports/inbound/time_tracking.rs
@@ -106,6 +106,15 @@ pub trait TimeTrackingService: Send + Sync + 'static {
date_range: (Date, Date),
) -> Result, TimeTrackingError>;
+ /// Lock a date range against further changes.
+ async fn lock_time_entries(&self, date_range: (Date, Date)) -> Result<(), TimeTrackingError>;
+
+ /// Unlock a date range, returning the days that stayed locked.
+ async fn unlock_time_entries(
+ &self,
+ date_range: (Date, Date),
+ ) -> Result, TimeTrackingError>;
+
/// Create a new time entry.
///
/// Creates the entry in the provider and persists to local timer history.
diff --git a/toki-api/src/domain/ports/outbound/time_tracking.rs b/toki-api/src/domain/ports/outbound/time_tracking.rs
index e0fe60d1..9f804457 100644
--- a/toki-api/src/domain/ports/outbound/time_tracking.rs
+++ b/toki-api/src/domain/ports/outbound/time_tracking.rs
@@ -61,6 +61,17 @@ pub trait TimeTrackingClient: Send + Sync + 'static {
date_range: (Date, Date),
) -> Result, TimeTrackingError>;
+ /// Lock a date range against further changes.
+ ///
+ /// Days that are already locked stay as they are.
+ async fn lock_time_entries(&self, date_range: (Date, Date)) -> Result<(), TimeTrackingError>;
+
+ /// Unlock a date range.
+ ///
+ /// The provider may leave days it refuses to unlock locked without an
+ /// error; read the day statuses to see them.
+ async fn unlock_time_entries(&self, date_range: (Date, Date)) -> Result<(), TimeTrackingError>;
+
/// Create a new time entry.
///
/// Returns the registration ID from the provider.
diff --git a/toki-api/src/domain/services/time_tracking.rs b/toki-api/src/domain/services/time_tracking.rs
index 15074542..26ab4cd7 100644
--- a/toki-api/src/domain/services/time_tracking.rs
+++ b/toki-api/src/domain/services/time_tracking.rs
@@ -364,6 +364,26 @@ impl TimeTrackingService
self.client.get_time_entry_day_statuses(date_range).await
}
+ async fn lock_time_entries(&self, date_range: (Date, Date)) -> Result<(), TimeTrackingError> {
+ ensure_ordered_range(date_range)?;
+ self.client.lock_time_entries(date_range).await
+ }
+
+ async fn unlock_time_entries(
+ &self,
+ date_range: (Date, Date),
+ ) -> Result, TimeTrackingError> {
+ ensure_ordered_range(date_range)?;
+ self.client.unlock_time_entries(date_range).await?;
+
+ let statuses = self.client.get_time_entry_day_statuses(date_range).await?;
+ Ok(statuses
+ .into_iter()
+ .filter(|day| day.status != TimeEntryStatus::Open)
+ .map(|day| day.date)
+ .collect())
+ }
+
async fn create_time_entry(
&self,
user_id: &UserId,
@@ -506,6 +526,16 @@ impl TimeTrackingService
}
}
+/// A provider may read a reversed range as its mirror image, so stop it here.
+fn ensure_ordered_range((from, to): (Date, Date)) -> Result<(), TimeTrackingError> {
+ if from > to {
+ return Err(TimeTrackingError::InvalidInput(
+ "The start date must not be after the end date".to_string(),
+ ));
+ }
+ Ok(())
+}
+
#[cfg(test)]
mod tests {
use super::*;
@@ -520,6 +550,8 @@ mod tests {
absence_children: Vec,
settled_flex: Option,
time_info_ranges: Mutex>,
+ day_statuses: Vec,
+ changed_ranges: Mutex>,
}
#[async_trait]
@@ -561,7 +593,23 @@ mod tests {
&self,
_date_range: (Date, Date),
) -> Result, TimeTrackingError> {
- unused_mock_method()
+ Ok(self.day_statuses.clone())
+ }
+
+ async fn lock_time_entries(
+ &self,
+ date_range: (Date, Date),
+ ) -> Result<(), TimeTrackingError> {
+ self.changed_ranges.lock().unwrap().push(date_range);
+ Ok(())
+ }
+
+ async fn unlock_time_entries(
+ &self,
+ date_range: (Date, Date),
+ ) -> Result<(), TimeTrackingError> {
+ self.changed_ranges.lock().unwrap().push(date_range);
+ Ok(())
}
async fn create_time_entry(
@@ -738,6 +786,68 @@ mod tests {
assert_eq!(saved_entry.end_time, Some(provider_request.end_time));
}
+ #[tokio::test]
+ async fn a_reversed_range_never_reaches_the_provider() {
+ let date = |day| Date::from_calendar_date(2026, time::Month::October, day).unwrap();
+ let client = Arc::new(MockTimeTrackingClient::default());
+ let repo = Arc::new(MockTimerHistoryRepository {
+ active_timer: Mutex::new(None),
+ saved_end_time: Mutex::new(None),
+ });
+ let service = TimeTrackingServiceImpl::new(client.clone(), repo);
+ let reversed = (date(30), date(26));
+
+ assert!(matches!(
+ service.lock_time_entries(reversed).await,
+ Err(TimeTrackingError::InvalidInput(_))
+ ));
+ assert!(matches!(
+ service.unlock_time_entries(reversed).await,
+ Err(TimeTrackingError::InvalidInput(_))
+ ));
+ assert!(client.changed_ranges.lock().unwrap().is_empty());
+
+ service
+ .lock_time_entries((date(26), date(26)))
+ .await
+ .unwrap();
+ assert_eq!(client.changed_ranges.lock().unwrap().len(), 1);
+ }
+
+ #[tokio::test]
+ async fn unlocking_reports_the_days_the_provider_kept_locked() {
+ let date = |day| Date::from_calendar_date(2026, time::Month::October, day).unwrap();
+ let client = Arc::new(MockTimeTrackingClient {
+ day_statuses: vec![
+ TimeEntryDayStatus {
+ date: date(22),
+ status: TimeEntryStatus::Certified,
+ },
+ TimeEntryDayStatus {
+ date: date(23),
+ status: TimeEntryStatus::Approved,
+ },
+ TimeEntryDayStatus {
+ date: date(26),
+ status: TimeEntryStatus::Open,
+ },
+ ],
+ ..Default::default()
+ });
+ let repo = Arc::new(MockTimerHistoryRepository {
+ active_timer: Mutex::new(None),
+ saved_end_time: Mutex::new(None),
+ });
+ let service = TimeTrackingServiceImpl::new(client.clone(), repo);
+
+ let still_locked = service
+ .unlock_time_entries((date(22), date(26)))
+ .await
+ .unwrap();
+
+ assert_eq!(still_locked, [date(22), date(23)]);
+ }
+
#[tokio::test]
async fn flex_balance_estimates_the_days_after_the_settled_balance() {
let date = |month, day| Date::from_calendar_date(2026, month, day).unwrap();
diff --git a/toki-api/src/routes/time_tracking/calendar.rs b/toki-api/src/routes/time_tracking/calendar.rs
index 0e8e51c1..de91fb89 100644
--- a/toki-api/src/routes/time_tracking/calendar.rs
+++ b/toki-api/src/routes/time_tracking/calendar.rs
@@ -3,7 +3,7 @@ use axum::{
http::StatusCode,
Json,
};
-use serde::Deserialize;
+use serde::{Deserialize, Serialize};
use utoipa::{IntoParams, ToSchema};
use crate::{
@@ -204,6 +204,56 @@ pub async fn get_time_entry_day_statuses(
Ok(Json(statuses.into_iter().map(Into::into).collect()))
}
+#[derive(Debug, Deserialize)]
+pub struct TimeEntryPeriodPayload {
+ from: String,
+ to: String,
+}
+
+#[derive(Debug, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct UnlockTimeEntriesResponse {
+ still_locked: Vec,
+}
+
+pub async fn lock_time_entries(
+ user: AuthUser,
+ State(app_state): State,
+ Json(payload): Json,
+) -> Result {
+ record_user_id(user.id);
+ let service = app_state
+ .time_tracking_factory
+ .create_service(user.id)
+ .await?;
+
+ let from = parse_date(&payload.from)?;
+ let to = parse_date(&payload.to)?;
+ service.lock_time_entries((from, to)).await?;
+
+ Ok(StatusCode::NO_CONTENT)
+}
+
+pub async fn unlock_time_entries(
+ user: AuthUser,
+ State(app_state): State,
+ Json(payload): Json,
+) -> Result, ApiError> {
+ record_user_id(user.id);
+ let service = app_state
+ .time_tracking_factory
+ .create_service(user.id)
+ .await?;
+
+ let from = parse_date(&payload.from)?;
+ let to = parse_date(&payload.to)?;
+ let still_locked = service.unlock_time_entries((from, to)).await?;
+
+ Ok(Json(UnlockTimeEntriesResponse {
+ still_locked: still_locked.iter().map(ToString::to_string).collect(),
+ }))
+}
+
// ============================================================================
// Time Entry Mutations (Create, Edit, Delete)
// ============================================================================
diff --git a/toki-api/src/routes/time_tracking/mod.rs b/toki-api/src/routes/time_tracking/mod.rs
index ec58e1a5..44879d56 100644
--- a/toki-api/src/routes/time_tracking/mod.rs
+++ b/toki-api/src/routes/time_tracking/mod.rs
@@ -6,7 +6,7 @@ pub(crate) mod projects;
pub(crate) mod timer;
use axum::{
- routing::{get, put},
+ routing::{get, post, put},
Router,
};
@@ -43,6 +43,8 @@ pub fn router() -> Router {
"/time-entry-day-statuses",
get(calendar::get_time_entry_day_statuses),
)
+ .route("/lock", post(calendar::lock_time_entries))
+ .route("/unlock", post(calendar::unlock_time_entries))
.route(
"/time-entries",
get(calendar::get_time_entries)
+