diff --git a/frontend/Cargo.toml b/frontend/Cargo.toml index 5fce158..bd17840 100644 --- a/frontend/Cargo.toml +++ b/frontend/Cargo.toml @@ -32,6 +32,23 @@ web-sys = { version = "0.3", features = [ "CssStyleDeclaration", "MediaQueryList", "MediaQueryListEvent", + # Notification API for browser notifications + "Notification", + "NotificationOptions", + "NotificationPermission", + # Service Worker API for background processing + "ServiceWorkerContainer", + "ServiceWorkerRegistration", + "MessageEvent", + # IndexedDB API for persistent alarm storage + "IdbDatabase", + "IdbObjectStore", + "IdbTransaction", + "IdbRequest", + "IdbKeyRange", + "IdbFactory", + "IdbOpenDbRequest", + "IdbVersionChangeEvent", ] } wasm-bindgen = "0.2" js-sys = "0.3" @@ -73,3 +90,6 @@ gloo-storage = "0.3" gloo-timers = "0.3" wasm-bindgen-futures = "0.4" +# IndexedDB for persistent alarm storage +indexed_db_futures = "0.4" + diff --git a/frontend/index.html b/frontend/index.html index 16d07dc..c5313b5 100644 --- a/frontend/index.html +++ b/frontend/index.html @@ -8,6 +8,7 @@ + @@ -17,6 +18,19 @@ window.addEventListener('TrunkApplicationStarted', () => { console.log("Trunk application started successfully!"); }); + + // Register service worker for alarm background processing + if ('serviceWorker' in navigator) { + window.addEventListener('load', () => { + navigator.serviceWorker.register('/service-worker.js') + .then((registration) => { + console.log('SW registered: ', registration); + }) + .catch((registrationError) => { + console.log('SW registration failed: ', registrationError); + }); + }); + } diff --git a/frontend/service-worker.js b/frontend/service-worker.js new file mode 100644 index 0000000..dbebc23 --- /dev/null +++ b/frontend/service-worker.js @@ -0,0 +1,156 @@ +// Calendar Alarms Service Worker +// Handles background alarm checking when the main app is not active + +const SW_VERSION = 'v1.0.0'; +const CACHE_NAME = `calendar-alarms-${SW_VERSION}`; +const STORAGE_KEY = 'calendar_alarms'; + +// Install event +self.addEventListener('install', event => { + console.log(`Service Worker ${SW_VERSION} installing...`); + self.skipWaiting(); // Activate immediately +}); + +// Activate event +self.addEventListener('activate', event => { + console.log(`Service Worker ${SW_VERSION} activated`); + event.waitUntil(self.clients.claim()); // Take control immediately +}); + +// Message handler for communication with main app +self.addEventListener('message', event => { + const { type, data } = event.data; + + switch (type) { + case 'CHECK_ALARMS': + handleCheckAlarms(event, data); + break; + case 'SCHEDULE_ALARM': + handleScheduleAlarm(data, event); + break; + case 'REMOVE_ALARM': + handleRemoveAlarm(data, event); + break; + case 'PING': + event.ports[0].postMessage({ type: 'PONG', version: SW_VERSION }); + break; + default: + console.warn('Unknown message type:', type); + } +}); + +// Handle alarm checking request +function handleCheckAlarms(event, data) { + try { + // Main app sends alarms data to check + const allAlarms = data?.alarms || []; + const dueAlarms = checkProvidedAlarms(allAlarms); + + // Send results back to main app + event.ports[0].postMessage({ + type: 'ALARMS_DUE', + data: dueAlarms + }); + + console.log(`Checked ${allAlarms.length} alarms, found ${dueAlarms.length} due`); + } catch (error) { + console.error('Error checking alarms:', error); + event.ports[0].postMessage({ + type: 'ALARM_CHECK_ERROR', + error: error.message + }); + } +} + +// Process alarms sent from main app +function checkProvidedAlarms(alarms) { + const now = new Date(); + const nowStr = formatDateTimeForComparison(now); + + // Filter alarms that should trigger and are pending + const dueAlarms = alarms.filter(alarm => { + return alarm.status === 'Pending' && alarm.trigger_time <= nowStr; + }); + + return dueAlarms; +} + +// Handle schedule alarm request (not needed with localStorage approach) +function handleScheduleAlarm(alarmData, event) { + // Service worker doesn't handle storage with localStorage approach + // Main app handles all storage operations + event.ports[0].postMessage({ + type: 'ALARM_SCHEDULED', + data: { success: true, alarmId: alarmData.id } + }); +} + +// Handle remove alarm request (not needed with localStorage approach) +function handleRemoveAlarm(alarmData, event) { + // Service worker doesn't handle storage with localStorage approach + // Main app handles all storage operations + event.ports[0].postMessage({ + type: 'ALARM_REMOVED', + data: { success: true, eventUid: alarmData.eventUid } + }); +} + + +// Format date time for comparison (YYYY-MM-DDTHH:MM:SS) +function formatDateTimeForComparison(date) { + return date.getFullYear() + '-' + + String(date.getMonth() + 1).padStart(2, '0') + '-' + + String(date.getDate()).padStart(2, '0') + 'T' + + String(date.getHours()).padStart(2, '0') + ':' + + String(date.getMinutes()).padStart(2, '0') + ':' + + String(date.getSeconds()).padStart(2, '0'); +} + +// Background alarm checking (runs periodically) +// Note: Service worker can't access localStorage, so this just pings the main app +setInterval(async () => { + try { + // Notify all clients to check their alarms + const clients = await self.clients.matchAll(); + + clients.forEach(client => { + client.postMessage({ + type: 'BACKGROUND_ALARM_CHECK_REQUEST' + }); + }); + + console.log('Requested alarm check from main app'); + } catch (error) { + console.error('Background alarm check failed:', error); + } +}, 60000); // Check every minute + +// Handle push notifications (for future enhancement) +self.addEventListener('push', event => { + console.log('Push notification received:', event); + // Future: Handle server-sent alarm notifications +}); + +// Handle notification clicks +self.addEventListener('notificationclick', event => { + console.log('Notification clicked:', event); + + event.notification.close(); + + // Focus or open the calendar app + event.waitUntil( + self.clients.matchAll().then(clients => { + // Try to focus existing client + for (const client of clients) { + if (client.url.includes('localhost') || client.url.includes(self.location.origin)) { + return client.focus(); + } + } + + // Open new window if no client exists + return self.clients.openWindow('/'); + }) + ); +}); + +console.log(`Calendar Alarms Service Worker ${SW_VERSION} loaded`); \ No newline at end of file diff --git a/frontend/src/app.rs b/frontend/src/app.rs index 0520ee6..fff05b4 100644 --- a/frontend/src/app.rs +++ b/frontend/src/app.rs @@ -6,7 +6,7 @@ use crate::components::{ use crate::components::mobile_warning_modal::is_mobile_device; use crate::components::sidebar::{Style}; use crate::models::ical::VEvent; -use crate::services::{calendar_service::{UserInfo, ExternalCalendar}, CalendarService}; +use crate::services::{calendar_service::{UserInfo, ExternalCalendar}, CalendarService, AlarmScheduler, AlarmStorage}; use chrono::NaiveDate; use gloo_storage::{LocalStorage, Storage}; use gloo_timers::callback::Interval; @@ -148,6 +148,12 @@ pub fn App() -> Html { // Mobile warning state let mobile_warning_open = use_state(|| is_mobile_device()); let refresh_interval = use_state(|| -> Option { None }); + + // Alarm system state + let alarm_scheduler = use_state(|| AlarmScheduler::new()); + let alarm_storage = use_state(|| AlarmStorage::new()); + let alarm_check_interval = use_state(|| -> Option { None }); + let alarm_storage_initialized = use_state(|| false); // Calendar view state - load from localStorage if available let current_view = use_state(|| { @@ -192,6 +198,92 @@ pub fn App() -> Html { }) }; + // Initialize alarm system after user login + { + let auth_token = auth_token.clone(); + let alarm_storage = alarm_storage.clone(); + let alarm_scheduler = alarm_scheduler.clone(); + let alarm_storage_initialized = alarm_storage_initialized.clone(); + let alarm_check_interval = alarm_check_interval.clone(); + + use_effect_with((*auth_token).clone(), move |token| { + if token.is_some() && !*alarm_storage_initialized { + web_sys::console::log_1(&"πŸ”” Initializing alarm system...".into()); + + let alarm_storage = alarm_storage.clone(); + let alarm_scheduler = alarm_scheduler.clone(); + let alarm_storage_initialized = alarm_storage_initialized.clone(); + let alarm_check_interval = alarm_check_interval.clone(); + + wasm_bindgen_futures::spawn_local(async move { + // Initialize IndexedDB storage + let mut storage = (*alarm_storage).clone(); + match storage.init().await { + Ok(()) => { + alarm_storage.set(storage); + alarm_storage_initialized.set(true); + + // Request notification permission + let scheduler = (*alarm_scheduler).clone(); + match scheduler.request_notification_permission().await { + Ok(permission) => { + web_sys::console::log_1( + &format!("πŸ”” Notification permission: {:?}", permission).into() + ); + } + Err(e) => { + web_sys::console::warn_1( + &format!("⚠️ Failed to request notification permission: {:?}", e).into() + ); + } + } + + alarm_scheduler.set(scheduler); + + // Set up alarm checking interval (every 30 seconds) + let interval = { + let alarm_scheduler_ref = alarm_scheduler.clone(); + Interval::new(30_000, move || { + web_sys::console::log_1(&"πŸ• DEBUG: Alarm check interval firing".into()); + // Get a fresh copy of the current scheduler state each time + let mut scheduler = (*alarm_scheduler_ref).clone(); + let triggered_count = scheduler.check_and_trigger_alarms(); + + if triggered_count > 0 { + web_sys::console::log_1( + &format!("πŸ”” Triggered {} alarm(s)", triggered_count).into() + ); + } else { + web_sys::console::log_1(&"πŸ• DEBUG: No alarms triggered this check".into()); + } + + // Update the scheduler state with any changes (like alarm status updates) + alarm_scheduler_ref.set(scheduler); + }) + }; + + alarm_check_interval.set(Some(interval)); + + web_sys::console::log_1(&"βœ… Alarm system initialized successfully".into()); + } + Err(e) => { + web_sys::console::error_1( + &format!("❌ Failed to initialize alarm storage: {:?}", e).into() + ); + } + } + }); + } else if token.is_none() { + // Clean up alarm system on logout + alarm_check_interval.set(None); // This will drop and cancel the interval + alarm_storage_initialized.set(false); + web_sys::console::log_1(&"πŸ”” Alarm system cleaned up".into()); + } + + || () + }); + } + // Function to refresh calendar data without full page reload let refresh_calendar_data = { let user_info = user_info.clone(); @@ -786,7 +878,9 @@ pub fn App() -> Html { let create_event_modal_open = create_event_modal_open.clone(); let auth_token = auth_token.clone(); let refresh_calendar_data = refresh_calendar_data.clone(); + let alarm_scheduler = alarm_scheduler.clone(); Callback::from(move |event_data: EventCreationData| { + let alarm_scheduler = alarm_scheduler.clone(); // Check if this is an update operation (has original_uid) or a create operation if let Some(original_uid) = event_data.original_uid.clone() { web_sys::console::log_1(&format!("Updating event via modal: {:?}", event_data).into()); @@ -830,7 +924,7 @@ pub fn App() -> Html { let update_result = if is_recurring && event_data_for_update.edit_scope.is_some() { // Only use series endpoint for existing recurring events being edited // Singletonβ†’series conversion should use regular update_event endpoint - let edit_action = event_data_for_update.edit_scope.unwrap(); + let edit_action = event_data_for_update.edit_scope.as_ref().unwrap(); let scope = match edit_action { crate::components::EditAction::EditAll => "all_in_series".to_string(), crate::components::EditAction::EditFuture => "this_and_future".to_string(), @@ -904,6 +998,45 @@ pub fn App() -> Html { match update_result { Ok(_) => { web_sys::console::log_1(&"Event updated successfully via modal".into()); + + // Re-schedule alarms for the updated event + let alarm_scheduler_for_update = alarm_scheduler.clone(); + let event_data_for_alarms = event_data_for_update.clone(); + let original_uid_for_alarms = original_uid.clone(); + + wasm_bindgen_futures::spawn_local(async move { + let mut scheduler = (*alarm_scheduler_for_update).clone(); + + // Remove old alarms for this event + scheduler.remove_event_alarms(&original_uid_for_alarms); + + // Schedule new alarms if any exist + if !event_data_for_alarms.alarms.is_empty() { + let params = event_data_for_alarms.to_create_event_params(); + + // Parse start date/time for alarm scheduling + if let (Ok(start_date), Ok(start_time)) = ( + chrono::NaiveDate::parse_from_str(¶ms.2, "%Y-%m-%d"), + chrono::NaiveTime::parse_from_str(¶ms.3, "%H:%M") + ) { + // Create a temporary VEvent for alarm scheduling + let start_datetime = start_date.and_time(start_time); + let mut temp_event = VEvent::new(original_uid_for_alarms.clone(), start_datetime); + temp_event.summary = Some(params.0.clone()); // title + temp_event.location = if params.6.is_empty() { None } else { Some(params.6.clone()) }; + temp_event.alarms = event_data_for_alarms.alarms.clone(); + + scheduler.schedule_event_alarms(&temp_event); + + web_sys::console::log_1( + &format!("πŸ”” Re-scheduled {} alarm(s) for updated event", temp_event.alarms.len()).into() + ); + } + } + + alarm_scheduler_for_update.set(scheduler); + }); + // Refresh calendar data without page reload refresh_callback.emit(()); } @@ -961,6 +1094,12 @@ pub fn App() -> Html { }; let params = event_data.to_create_event_params(); + // Clone values we'll need for alarm scheduling + let title_for_alarms = params.0.clone(); + let start_date_for_alarms = params.2.clone(); + let start_time_for_alarms = params.3.clone(); + let location_for_alarms = params.6.clone(); + let create_result = _calendar_service .create_event( &_token, &_password, params.0, // title @@ -990,6 +1129,36 @@ pub fn App() -> Html { match create_result { Ok(_) => { web_sys::console::log_1(&"Event created successfully".into()); + + // Schedule alarms for the created event if any exist + if !event_data.alarms.is_empty() { + // Since create_event doesn't return the UID, we need to generate one + // The backend should be using the same UUID generation logic + let event_uid = uuid::Uuid::new_v4().to_string(); + + // Parse start date/time for alarm scheduling + if let (Ok(start_date), Ok(start_time)) = ( + chrono::NaiveDate::parse_from_str(&start_date_for_alarms, "%Y-%m-%d"), + chrono::NaiveTime::parse_from_str(&start_time_for_alarms, "%H:%M") + ) { + // Create a temporary VEvent for alarm scheduling + let start_datetime = start_date.and_time(start_time); + let mut temp_event = VEvent::new(event_uid.clone(), start_datetime); + temp_event.summary = Some(title_for_alarms.clone()); + temp_event.location = if location_for_alarms.is_empty() { None } else { Some(location_for_alarms.clone()) }; + temp_event.alarms = event_data.alarms.clone(); + + // Schedule alarms for the new event (synchronously) + let mut scheduler = (*alarm_scheduler).clone(); + scheduler.schedule_event_alarms(&temp_event); + alarm_scheduler.set(scheduler); + + web_sys::console::log_1( + &format!("πŸ”” Scheduled {} alarm(s) for new event", temp_event.alarms.len()).into() + ); + } + } + // Refresh calendar data without page reload refresh_callback.emit(()); } diff --git a/frontend/src/services/alarm_scheduler.rs b/frontend/src/services/alarm_scheduler.rs new file mode 100644 index 0000000..dd9bc8c --- /dev/null +++ b/frontend/src/services/alarm_scheduler.rs @@ -0,0 +1,465 @@ +use calendar_models::{VAlarm, AlarmAction, AlarmTrigger, VEvent}; +use chrono::{Duration, Local, NaiveDateTime}; +use serde::{Deserialize, Serialize}; +use std::collections::HashMap; +use crate::services::{NotificationManager, AlarmNotification}; +use gloo_storage::{LocalStorage, Storage}; + +#[derive(Debug, Clone, Serialize, Deserialize)] +pub struct ScheduledAlarm { + pub id: String, // Unique alarm ID + pub event_uid: String, // Event this alarm belongs to + pub event_summary: String, // Event title for notification + pub event_location: Option, // Event location for notification + pub event_start: NaiveDateTime, // Event start time (local) + pub trigger_time: NaiveDateTime, // When alarm should trigger (local) + pub alarm_action: AlarmAction, // Type of alarm + pub status: AlarmStatus, // Current status + pub created_at: NaiveDateTime, // When alarm was scheduled +} + +#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)] +pub enum AlarmStatus { + Pending, // Waiting to trigger + Triggered, // Has been triggered + Dismissed, // User dismissed + Expired, // Past due (event ended) +} + +#[derive(Debug, Clone)] +pub struct AlarmScheduler { + scheduled_alarms: HashMap, + notification_manager: NotificationManager, + instance_id: String, // Unique identifier for debugging +} + +const ALARMS_STORAGE_KEY: &str = "scheduled_alarms"; + +impl AlarmScheduler { + pub fn new() -> Self { + let instance_id = format!("scheduler_{}", chrono::Local::now().timestamp_nanos_opt().unwrap_or(0)); + let mut scheduler = Self { + scheduled_alarms: HashMap::new(), + notification_manager: NotificationManager::new(), + instance_id, + }; + + // Load alarms from localStorage + scheduler.load_alarms_from_storage(); + scheduler + } + + /// Load alarms from localStorage + fn load_alarms_from_storage(&mut self) { + if let Ok(alarms) = LocalStorage::get::>(ALARMS_STORAGE_KEY) { + self.scheduled_alarms = alarms; + web_sys::console::log_1( + &format!("πŸ”” DEBUG: [{}] Loaded {} alarms from localStorage", + self.instance_id, + self.scheduled_alarms.len() + ).into() + ); + } + } + + /// Save alarms to localStorage + fn save_alarms_to_storage(&self) { + if let Err(e) = LocalStorage::set(ALARMS_STORAGE_KEY, &self.scheduled_alarms) { + web_sys::console::error_1( + &format!("Failed to save alarms to localStorage: {:?}", e).into() + ); + } else { + web_sys::console::log_1( + &format!("πŸ”” DEBUG: [{}] Saved {} alarms to localStorage", + self.instance_id, + self.scheduled_alarms.len() + ).into() + ); + } + } + + /// Schedule alarms for an event + pub fn schedule_event_alarms(&mut self, event: &VEvent) { + web_sys::console::log_1( + &format!("πŸ”” DEBUG: [{}] schedule_event_alarms called for event '{}' with {} alarms", + self.instance_id, + event.summary.as_ref().unwrap_or(&"Unknown".to_string()), + event.alarms.len() + ).into() + ); + + // Check notification permission before scheduling + let permission = NotificationManager::get_permission(); + if permission != web_sys::NotificationPermission::Granted && !event.alarms.is_empty() { + web_sys::console::warn_1( + &format!("⚠️ Scheduling alarms but notification permission is {:?}. Will request permission.", permission).into() + ); + + // Try to force request permission asynchronously + wasm_bindgen_futures::spawn_local(async move { + match NotificationManager::force_request_permission().await { + Ok(new_permission) => { + web_sys::console::log_1( + &format!("πŸ”” Force requested notification permission: {:?}", new_permission).into() + ); + } + Err(e) => { + web_sys::console::error_1( + &format!("❌ Failed to force request notification permission: {:?}", e).into() + ); + } + } + }); + } + + // Remove any existing alarms for this event + self.remove_event_alarms(&event.uid); + + // Get event details + let event_summary = event.summary.as_ref().unwrap_or(&"Untitled Event".to_string()).clone(); + let event_location = event.location.clone(); + let event_start = event.dtstart; + + // Schedule each alarm + for alarm in &event.alarms { + if let Some(scheduled_alarm) = self.create_scheduled_alarm( + event, + alarm, + &event_summary, + &event_location, + event_start, + ) { + web_sys::console::log_1( + &format!("πŸ”” DEBUG: [{}] Adding alarm to scheduler: {}", self.instance_id, scheduled_alarm.id).into() + ); + self.scheduled_alarms.insert(scheduled_alarm.id.clone(), scheduled_alarm); + web_sys::console::log_1( + &format!("πŸ”” DEBUG: [{}] Scheduler now has {} total alarms", self.instance_id, self.scheduled_alarms.len()).into() + ); + } + } + + web_sys::console::log_1( + &format!("Scheduled {} alarms for event: {}", event.alarms.len(), event_summary).into() + ); + + // Save to localStorage + self.save_alarms_to_storage(); + + // Debug: Log scheduled alarm details + for alarm in &event.alarms { + if let Some(scheduled_alarm) = self.create_scheduled_alarm(event, alarm, &event_summary, &event_location, event_start) { + web_sys::console::log_1( + &format!("πŸ”” DEBUG: Scheduled alarm ID {} for event '{}' to trigger at {} (event starts at {})", + scheduled_alarm.id, + scheduled_alarm.event_summary, + scheduled_alarm.trigger_time.format("%Y-%m-%d %H:%M:%S"), + scheduled_alarm.event_start.format("%Y-%m-%d %H:%M:%S") + ).into() + ); + } + } + } + + /// Create a scheduled alarm from a VAlarm + fn create_scheduled_alarm( + &self, + event: &VEvent, + valarm: &VAlarm, + event_summary: &str, + event_location: &Option, + event_start: NaiveDateTime, + ) -> Option { + // Only handle Display alarms for now + if valarm.action != AlarmAction::Display { + return None; + } + + // Calculate trigger time + let trigger_time = match &valarm.trigger { + AlarmTrigger::Duration(duration) => { + // Duration relative to event start + let trigger_time = event_start + *duration; + + // Ensure trigger time is not in the past (with 30 second tolerance) + let now = Local::now().naive_local(); + if trigger_time < now - Duration::seconds(30) { + web_sys::console::warn_1( + &format!("Skipping past alarm for event: {} (trigger: {})", + event_summary, + trigger_time.format("%Y-%m-%d %H:%M:%S") + ).into() + ); + return None; + } + + trigger_time + } + AlarmTrigger::DateTime(datetime) => { + // Absolute datetime - convert to local time + let local_trigger = datetime.with_timezone(&Local).naive_local(); + + // Ensure trigger time is not in the past + let now = Local::now().naive_local(); + if local_trigger < now - Duration::seconds(30) { + web_sys::console::warn_1( + &format!("Skipping past absolute alarm for event: {} (trigger: {})", + event_summary, + local_trigger.format("%Y-%m-%d %H:%M:%S") + ).into() + ); + return None; + } + + local_trigger + } + }; + + // Generate unique alarm ID + let alarm_id = format!("{}_{}", event.uid, trigger_time.and_utc().timestamp()); + + Some(ScheduledAlarm { + id: alarm_id, + event_uid: event.uid.clone(), + event_summary: event_summary.to_string(), + event_location: event_location.clone(), + event_start, + trigger_time, + alarm_action: valarm.action.clone(), + status: AlarmStatus::Pending, + created_at: Local::now().naive_local(), + }) + } + + /// Remove all alarms for an event + pub fn remove_event_alarms(&mut self, event_uid: &str) { + let alarm_ids: Vec = self.scheduled_alarms + .iter() + .filter(|(_, alarm)| alarm.event_uid == event_uid) + .map(|(id, _)| id.clone()) + .collect(); + + for alarm_id in alarm_ids { + self.scheduled_alarms.remove(&alarm_id); + } + + // Also close any active notifications for this event + self.notification_manager.close_notification(event_uid); + + web_sys::console::log_1(&format!("Removed alarms for event: {}", event_uid).into()); + + // Save to localStorage + self.save_alarms_to_storage(); + } + + /// Check for alarms that should trigger now and trigger them + pub fn check_and_trigger_alarms(&mut self) -> usize { + // Reload alarms from localStorage to ensure we have the latest data + self.load_alarms_from_storage(); + + let now = Local::now().naive_local(); + let mut triggered_count = 0; + + web_sys::console::log_1( + &format!("πŸ• DEBUG: [{}] Checking alarms at {} - total {} alarms, {} pending", + self.instance_id, + now.format("%Y-%m-%d %H:%M:%S"), + self.scheduled_alarms.len(), + self.scheduled_alarms.values().filter(|a| a.status == AlarmStatus::Pending).count() + ).into() + ); + + // Find alarms that should trigger (within 30 seconds tolerance) + let alarms_to_trigger: Vec = self.scheduled_alarms + .values() + .filter(|alarm| { + let should_trigger = alarm.status == AlarmStatus::Pending && + alarm.trigger_time <= now + Duration::seconds(30) && + alarm.trigger_time >= now - Duration::seconds(30); + + if alarm.status == AlarmStatus::Pending { + web_sys::console::log_1( + &format!("πŸ” DEBUG: Pending alarm '{}' trigger: {} vs now: {} - should trigger: {}", + alarm.event_summary, + alarm.trigger_time.format("%Y-%m-%d %H:%M:%S"), + now.format("%Y-%m-%d %H:%M:%S"), + should_trigger + ).into() + ); + } + + should_trigger + }) + .cloned() + .collect(); + + web_sys::console::log_1( + &format!("πŸ”” DEBUG: Found {} alarms to trigger", alarms_to_trigger.len()).into() + ); + + for alarm in alarms_to_trigger { + web_sys::console::log_1( + &format!("⏰ DEBUG: Attempting to trigger alarm for '{}'", alarm.event_summary).into() + ); + + if self.trigger_alarm(&alarm) { + // Mark alarm as triggered + if let Some(scheduled_alarm) = self.scheduled_alarms.get_mut(&alarm.id) { + scheduled_alarm.status = AlarmStatus::Triggered; + } + triggered_count += 1; + web_sys::console::log_1( + &format!("βœ… DEBUG: Successfully triggered alarm for '{}'", alarm.event_summary).into() + ); + } else { + web_sys::console::log_1( + &format!("❌ DEBUG: Failed to trigger alarm for '{}'", alarm.event_summary).into() + ); + } + } + + // Clean up expired alarms (events that ended more than 1 hour ago) + self.cleanup_expired_alarms(); + + // Save to localStorage if any changes were made + if triggered_count > 0 { + self.save_alarms_to_storage(); + } + + triggered_count + } + + /// Trigger a specific alarm + fn trigger_alarm(&mut self, alarm: &ScheduledAlarm) -> bool { + web_sys::console::log_1( + &format!("πŸ”” DEBUG: trigger_alarm called for '{}'", alarm.event_summary).into() + ); + + // Check notification permission + let permission = NotificationManager::get_permission(); + web_sys::console::log_1( + &format!("πŸ”” DEBUG: Notification permission: {:?}", permission).into() + ); + + // Don't trigger if already showing notification for this event + if self.notification_manager.has_notification(&alarm.event_uid) { + web_sys::console::log_1( + &format!("πŸ”” DEBUG: Skipping alarm for '{}' - notification already showing", alarm.event_summary).into() + ); + return false; + } + + let alarm_notification = AlarmNotification { + event_uid: alarm.event_uid.clone(), + event_summary: alarm.event_summary.clone(), + event_location: alarm.event_location.clone(), + alarm_time: alarm.event_start, + }; + + web_sys::console::log_1( + &format!("πŸ”” DEBUG: About to call show_alarm_notification for '{}'", alarm.event_summary).into() + ); + + match self.notification_manager.show_alarm_notification(alarm_notification) { + Ok(()) => { + web_sys::console::log_1( + &format!("βœ… Triggered alarm for: {}", alarm.event_summary).into() + ); + true + } + Err(err) => { + web_sys::console::error_1( + &format!("❌ Failed to trigger alarm: {:?}", err).into() + ); + false + } + } + } + + /// Clean up expired alarms + fn cleanup_expired_alarms(&mut self) { + let now = Local::now().naive_local(); + let cutoff_time = now - Duration::hours(1); + + let expired_alarm_ids: Vec = self.scheduled_alarms + .iter() + .filter(|(_, alarm)| { + // Mark as expired if event ended more than 1 hour ago + alarm.event_start < cutoff_time + }) + .map(|(id, _)| id.clone()) + .collect(); + + for alarm_id in &expired_alarm_ids { + if let Some(alarm) = self.scheduled_alarms.get_mut(alarm_id) { + alarm.status = AlarmStatus::Expired; + } + } + + // Remove expired alarms from memory + let had_expired = !expired_alarm_ids.is_empty(); + for alarm_id in expired_alarm_ids { + self.scheduled_alarms.remove(&alarm_id); + } + + // Save to localStorage if any expired alarms were removed + if had_expired { + self.save_alarms_to_storage(); + } + } + + /// Get all pending alarms + pub fn get_pending_alarms(&self) -> Vec<&ScheduledAlarm> { + self.scheduled_alarms + .values() + .filter(|alarm| alarm.status == AlarmStatus::Pending) + .collect() + } + + /// Get next alarm time + pub fn get_next_alarm_time(&self) -> Option { + self.get_pending_alarms() + .iter() + .map(|alarm| alarm.trigger_time) + .min() + } + + /// Get count of pending alarms + pub fn pending_count(&self) -> usize { + self.get_pending_alarms().len() + } + + /// Request notification permission + pub async fn request_notification_permission(&self) -> Result { + NotificationManager::request_permission().await + } + + /// Check if notifications are supported and permitted + pub fn can_show_notifications(&self) -> bool { + NotificationManager::is_supported() && + NotificationManager::get_permission() == web_sys::NotificationPermission::Granted + } + + /// Get notification permission status + pub fn get_notification_permission(&self) -> web_sys::NotificationPermission { + NotificationManager::get_permission() + } + + /// Dismiss alarm for an event (close notification) + pub fn dismiss_alarm(&mut self, event_uid: &str) { + self.notification_manager.close_notification(event_uid); + + // Mark alarms as dismissed + for alarm in self.scheduled_alarms.values_mut() { + if alarm.event_uid == event_uid && alarm.status == AlarmStatus::Triggered { + alarm.status = AlarmStatus::Dismissed; + } + } + } +} + +impl Default for AlarmScheduler { + fn default() -> Self { + Self::new() + } +} \ No newline at end of file diff --git a/frontend/src/services/alarm_storage.rs b/frontend/src/services/alarm_storage.rs new file mode 100644 index 0000000..9b84a41 --- /dev/null +++ b/frontend/src/services/alarm_storage.rs @@ -0,0 +1,117 @@ +use serde::{Deserialize, Serialize}; +use chrono::NaiveDateTime; +use crate::services::{ScheduledAlarm, AlarmStatus}; +use gloo_storage::{LocalStorage, Storage}; +use std::collections::HashMap; + +const STORAGE_KEY: &str = "calendar_alarms"; + +#[derive(Debug, Clone)] +pub struct AlarmStorage; + +impl AlarmStorage { + pub fn new() -> Self { + Self + } + + /// Initialize the storage (no-op for localStorage) + pub async fn init(&mut self) -> Result<(), wasm_bindgen::JsValue> { + web_sys::console::log_1(&"AlarmStorage initialized with localStorage".into()); + Ok(()) + } + + /// Load all alarms from localStorage + fn load_all_alarms() -> HashMap { + LocalStorage::get::>(STORAGE_KEY) + .unwrap_or_default() + } + + /// Save all alarms to localStorage + fn save_all_alarms(alarms: &HashMap) { + let _ = LocalStorage::set(STORAGE_KEY, alarms); + } + + /// Store a scheduled alarm + pub async fn store_alarm(&self, alarm: &ScheduledAlarm) -> Result<(), wasm_bindgen::JsValue> { + let mut all_alarms = Self::load_all_alarms(); + all_alarms.insert(alarm.id.clone(), alarm.clone()); + Self::save_all_alarms(&all_alarms); + Ok(()) + } + + /// Store multiple alarms + pub async fn store_alarms(&self, alarms: &[ScheduledAlarm]) -> Result<(), wasm_bindgen::JsValue> { + let mut all_alarms = Self::load_all_alarms(); + for alarm in alarms { + all_alarms.insert(alarm.id.clone(), alarm.clone()); + } + Self::save_all_alarms(&all_alarms); + Ok(()) + } + + /// Load all alarms + pub async fn load_alarms(&self) -> Result, wasm_bindgen::JsValue> { + let all_alarms = Self::load_all_alarms(); + Ok(all_alarms.values().cloned().collect()) + } + + /// Load alarms for a specific event + pub async fn load_event_alarms(&self, event_uid: &str) -> Result, wasm_bindgen::JsValue> { + let all_alarms = Self::load_all_alarms(); + let event_alarms: Vec = all_alarms + .values() + .filter(|alarm| alarm.event_uid == event_uid) + .cloned() + .collect(); + Ok(event_alarms) + } + + /// Load pending alarms that should trigger before a specific time + pub async fn load_pending_alarms_before(&self, before_time: NaiveDateTime) -> Result, wasm_bindgen::JsValue> { + let all_alarms = Self::load_all_alarms(); + let pending_alarms: Vec = all_alarms + .values() + .filter(|alarm| { + alarm.status == AlarmStatus::Pending && alarm.trigger_time <= before_time + }) + .cloned() + .collect(); + Ok(pending_alarms) + } + + /// Update alarm status + pub async fn update_alarm_status(&self, alarm_id: &str, status: AlarmStatus) -> Result<(), wasm_bindgen::JsValue> { + let mut all_alarms = Self::load_all_alarms(); + if let Some(alarm) = all_alarms.get_mut(alarm_id) { + alarm.status = status; + } + Self::save_all_alarms(&all_alarms); + Ok(()) + } + + /// Delete alarms for an event + pub async fn delete_event_alarms(&self, event_uid: &str) -> Result<(), wasm_bindgen::JsValue> { + let mut all_alarms = Self::load_all_alarms(); + all_alarms.retain(|_, alarm| alarm.event_uid != event_uid); + Self::save_all_alarms(&all_alarms); + Ok(()) + } + + /// Clean up expired alarms + pub async fn cleanup_expired_alarms(&self, cutoff_time: NaiveDateTime) -> Result { + let mut all_alarms = Self::load_all_alarms(); + let initial_count = all_alarms.len(); + + all_alarms.retain(|_, alarm| alarm.event_start >= cutoff_time); + + let deleted_count = initial_count - all_alarms.len(); + Self::save_all_alarms(&all_alarms); + Ok(deleted_count) + } +} + +impl Default for AlarmStorage { + fn default() -> Self { + Self::new() + } +} \ No newline at end of file diff --git a/frontend/src/services/mod.rs b/frontend/src/services/mod.rs index 4e94db2..1fccc5c 100644 --- a/frontend/src/services/mod.rs +++ b/frontend/src/services/mod.rs @@ -1,4 +1,10 @@ pub mod calendar_service; pub mod preferences; +pub mod notification_manager; +pub mod alarm_scheduler; +pub mod alarm_storage; pub use calendar_service::CalendarService; +pub use notification_manager::{NotificationManager, AlarmNotification}; +pub use alarm_scheduler::{AlarmScheduler, ScheduledAlarm, AlarmStatus}; +pub use alarm_storage::AlarmStorage; diff --git a/frontend/src/services/notification_manager.rs b/frontend/src/services/notification_manager.rs new file mode 100644 index 0000000..9b4765f --- /dev/null +++ b/frontend/src/services/notification_manager.rs @@ -0,0 +1,262 @@ +use web_sys::{window, Notification, NotificationOptions, NotificationPermission}; +use wasm_bindgen::prelude::*; +use wasm_bindgen_futures::JsFuture; +use std::collections::HashMap; + +#[derive(Debug, Clone)] +pub struct NotificationManager { + // Track displayed notifications to prevent duplicates + active_notifications: HashMap, +} + +#[derive(Debug, Clone)] +pub struct AlarmNotification { + pub event_uid: String, + pub event_summary: String, + pub event_location: Option, + pub alarm_time: chrono::NaiveDateTime, +} + +impl NotificationManager { + pub fn new() -> Self { + Self { + active_notifications: HashMap::new(), + } + } + + /// Check if the browser supports notifications + pub fn is_supported() -> bool { + // Check if the Notification constructor exists on the window + if let Some(window) = window() { + let has_notification = js_sys::Reflect::has(&window, &"Notification".into()).unwrap_or(false); + + // Additional debugging - try to access Notification directly via JsValue + let window_js: &wasm_bindgen::JsValue = window.as_ref(); + let direct_check = js_sys::Reflect::get(window_js, &"Notification".into()).unwrap_or(wasm_bindgen::JsValue::UNDEFINED); + let has_direct = !direct_check.is_undefined(); + + web_sys::console::log_1( + &format!("πŸ”” DEBUG: Notification API checks - Reflect.has: {}, direct access: {}", + has_notification, has_direct).into() + ); + + // Use either check + let result = has_notification || has_direct; + result + } else { + web_sys::console::log_1(&"πŸ”” DEBUG: No window object available".into()); + false + } + } + + /// Get current notification permission status + pub fn get_permission() -> NotificationPermission { + if Self::is_supported() { + Notification::permission() + } else { + NotificationPermission::Denied + } + } + + /// Force request notification permission (even if previously denied) + pub async fn force_request_permission() -> Result { + web_sys::console::log_1(&"πŸ”” DEBUG: force_request_permission called".into()); + + if !Self::is_supported() { + web_sys::console::log_1(&"πŸ”” DEBUG: Notifications not supported".into()); + return Ok(NotificationPermission::Denied); + } + + // Always request permission, regardless of current status + web_sys::console::log_1(&"πŸ”” DEBUG: Force calling Notification::request_permission()".into()); + let promise = Notification::request_permission()?; + let js_value = JsFuture::from(promise).await?; + + web_sys::console::log_1( + &format!("πŸ”” DEBUG: Force permission request completed with result: {:?}", js_value).into() + ); + + // Convert JS string back to NotificationPermission + if let Some(permission_str) = js_value.as_string() { + let result = match permission_str.as_str() { + "granted" => Ok(NotificationPermission::Granted), + "denied" => Ok(NotificationPermission::Denied), + _ => Ok(NotificationPermission::Default), + }; + web_sys::console::log_1( + &format!("πŸ”” DEBUG: Force returning permission: {:?}", result).into() + ); + result + } else { + web_sys::console::log_1(&"πŸ”” DEBUG: Force permission result was not a string, returning Denied".into()); + Ok(NotificationPermission::Denied) + } + } + + /// Request notification permission from the user + pub async fn request_permission() -> Result { + web_sys::console::log_1(&"πŸ”” DEBUG: request_permission called".into()); + + if !Self::is_supported() { + web_sys::console::log_1(&"πŸ”” DEBUG: Notifications not supported".into()); + return Ok(NotificationPermission::Denied); + } + + // Check current permission status + let current_permission = Notification::permission(); + web_sys::console::log_1( + &format!("πŸ”” DEBUG: Current permission status: {:?}", current_permission).into() + ); + + if current_permission != NotificationPermission::Default { + web_sys::console::log_1( + &format!("πŸ”” DEBUG: Permission already set to {:?}, not requesting again", current_permission).into() + ); + return Ok(current_permission); + } + + // Request permission + web_sys::console::log_1(&"πŸ”” DEBUG: Calling Notification::request_permission()".into()); + let promise = Notification::request_permission()?; + let js_value = JsFuture::from(promise).await?; + + web_sys::console::log_1( + &format!("πŸ”” DEBUG: Permission request completed with result: {:?}", js_value).into() + ); + + // Convert JS string back to NotificationPermission + if let Some(permission_str) = js_value.as_string() { + let result = match permission_str.as_str() { + "granted" => Ok(NotificationPermission::Granted), + "denied" => Ok(NotificationPermission::Denied), + _ => Ok(NotificationPermission::Default), + }; + web_sys::console::log_1( + &format!("πŸ”” DEBUG: Returning permission: {:?}", result).into() + ); + result + } else { + web_sys::console::log_1(&"πŸ”” DEBUG: Permission result was not a string, returning Denied".into()); + Ok(NotificationPermission::Denied) + } + } + + /// Display a notification for an alarm + pub fn show_alarm_notification(&mut self, alarm: AlarmNotification) -> Result<(), JsValue> { + web_sys::console::log_1( + &format!("πŸ”” DEBUG: show_alarm_notification called for '{}'", alarm.event_summary).into() + ); + + // Check permission + let permission = Self::get_permission(); + web_sys::console::log_1( + &format!("πŸ”” DEBUG: Permission check: {:?}", permission).into() + ); + + if permission != NotificationPermission::Granted { + web_sys::console::warn_1(&"❌ Notification permission not granted".into()); + return Ok(()); // Don't error, just skip + } + + // Check if notification already exists for this event + if self.active_notifications.contains_key(&alarm.event_uid) { + web_sys::console::log_1( + &format!("πŸ”” DEBUG: Skipping - notification already exists for event: {}", alarm.event_uid).into() + ); + return Ok(()); // Already showing notification for this event + } + + // Create notification options + let mut options = NotificationOptions::new(); + + // Set notification body with time and location + let body = if let Some(location) = &alarm.event_location { + format!("πŸ“… {}\nπŸ“ {}", + alarm.alarm_time.format("%H:%M"), + location + ) + } else { + format!("πŸ“… {}", alarm.alarm_time.format("%H:%M")) + }; + options.set_body(&body); + + // Set icon + options.set_icon("/favicon.ico"); + + // Set tag to prevent duplicates + options.set_tag(&alarm.event_uid); + + // Set require interaction to keep notification visible + options.set_require_interaction(true); + + // Create and show notification + web_sys::console::log_1( + &format!("πŸ”” DEBUG: Creating notification with title: '{}' and body: '{}'", alarm.event_summary, body).into() + ); + + let notification = Notification::new_with_options(&alarm.event_summary, &options)?; + + web_sys::console::log_1(&"πŸ”” DEBUG: Notification created successfully".into()); + + // Store reference to track active notifications + self.active_notifications.insert(alarm.event_uid.clone(), notification.clone()); + + // Set up click handler to focus the calendar app + let event_uid = alarm.event_uid.clone(); + let onclick_closure = Closure::wrap(Box::new(move |_event: web_sys::Event| { + // Focus the window when notification is clicked + if let Some(window) = window() { + let _ = window.focus(); + } + + web_sys::console::log_1(&format!("Notification clicked for event: {}", event_uid).into()); + }) as Box); + + notification.set_onclick(Some(onclick_closure.as_ref().unchecked_ref())); + onclick_closure.forget(); // Keep closure alive + + // Set up close handler to clean up tracking + let event_uid_close = alarm.event_uid.clone(); + let mut active_notifications_close = self.active_notifications.clone(); + let onclose_closure = Closure::wrap(Box::new(move |_event: web_sys::Event| { + active_notifications_close.remove(&event_uid_close); + }) as Box); + + notification.set_onclose(Some(onclose_closure.as_ref().unchecked_ref())); + onclose_closure.forget(); // Keep closure alive + + web_sys::console::log_1(&format!("Displayed notification for: {}", alarm.event_summary).into()); + + Ok(()) + } + + /// Close notification for a specific event + pub fn close_notification(&mut self, event_uid: &str) { + if let Some(notification) = self.active_notifications.remove(event_uid) { + notification.close(); + } + } + + /// Close all active notifications + pub fn close_all_notifications(&mut self) { + for (_, notification) in self.active_notifications.drain() { + notification.close(); + } + } + + /// Get count of active notifications + pub fn active_count(&self) -> usize { + self.active_notifications.len() + } + + /// Check if notification exists for event + pub fn has_notification(&self, event_uid: &str) -> bool { + self.active_notifications.contains_key(event_uid) + } +} + +impl Default for NotificationManager { + fn default() -> Self { + Self::new() + } +} \ No newline at end of file