connor/calendar
1
0
Fork 0
Code Issues 2 Pull Requests Actions Packages Projects Releases Wiki Activity

Clean up debug logging from notification system

Browse Source 
- Remove verbose debug console logs from alarm scheduler
- Remove debug logs from notification manager
- Keep essential error logging for troubleshooting
- Maintain clean, production-ready code
- System functionality unchanged

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <noreply@anthropic.com>
This commit is contained in:
Connor Johnstone
2025-09-21 21:22:19 -04:00
parent 1538869f4a
commit 7caf3539f7
3 changed files with 13 additions and 202 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
frontend/src/app.rs
View File

@@ -244,7 +244,6 @@ pub fn App() -> Html {
let interval = { let interval = {
let alarm_scheduler_ref = alarm_scheduler.clone(); let alarm_scheduler_ref = alarm_scheduler.clone();
Interval::new(30_000, move || { 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 // Get a fresh copy of the current scheduler state each time
let mut scheduler = (*alarm_scheduler_ref).clone(); let mut scheduler = (*alarm_scheduler_ref).clone();
let triggered_count = scheduler.check_and_trigger_alarms(); let triggered_count = scheduler.check_and_trigger_alarms();
@@ -253,8 +252,6 @@ pub fn App() -> Html {
web_sys::console::log_1( web_sys::console::log_1(
&format!("🔔 Triggered {} alarm(s)", triggered_count).into() &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) // Update the scheduler state with any changes (like alarm status updates)
@@ -918,9 +915,6 @@ pub fn App() -> Html {
crate::components::event_form::RecurrenceType::Monthly | crate::components::event_form::RecurrenceType::Monthly |
crate::components::event_form::RecurrenceType::Yearly); crate::components::event_form::RecurrenceType::Yearly);
web_sys::console::log_1(&format!("🐛 FRONTEND DEBUG: is_recurring={}, edit_scope={:?}, original_uid={:?}",
is_recurring, event_data_for_update.edit_scope, event_data_for_update.original_uid).into());
let update_result = if is_recurring && event_data_for_update.edit_scope.is_some() { let update_result = if is_recurring && event_data_for_update.edit_scope.is_some() {
// Only use series endpoint for existing recurring events being edited // Only use series endpoint for existing recurring events being edited
// Singleton→series conversion should use regular update_event endpoint // Singleton→series conversion should use regular update_event endpoint

133
frontend/src/services/alarm_scheduler.rs
View File

@@ -53,12 +53,6 @@ impl AlarmScheduler {
fn load_alarms_from_storage(&mut self) { fn load_alarms_from_storage(&mut self) {
if let Ok(alarms) = LocalStorage::get::<HashMap<String, ScheduledAlarm>>(ALARMS_STORAGE_KEY) { if let Ok(alarms) = LocalStorage::get::<HashMap<String, ScheduledAlarm>>(ALARMS_STORAGE_KEY) {
self.scheduled_alarms = alarms; self.scheduled_alarms = alarms;
web_sys::console::log_1(
&format!("🔔 DEBUG: [{}] Loaded {} alarms from localStorage",
self.instance_id,
self.scheduled_alarms.len()
).into()
);
} }
} }
@@ -68,47 +62,17 @@ impl AlarmScheduler {
web_sys::console::error_1( web_sys::console::error_1(
&format!("Failed to save alarms to localStorage: {:?}", e).into() &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 /// Schedule alarms for an event
pub fn schedule_event_alarms(&mut self, event: &VEvent) { 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 // Check notification permission before scheduling
let permission = NotificationManager::get_permission(); let permission = NotificationManager::get_permission();
if permission != web_sys::NotificationPermission::Granted && !event.alarms.is_empty() { 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 // Try to force request permission asynchronously
wasm_bindgen_futures::spawn_local(async move { wasm_bindgen_futures::spawn_local(async move {
match NotificationManager::force_request_permission().await { let _ = 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()
);
}
}
}); });
} }
@@ -129,36 +93,12 @@ impl AlarmScheduler {
&event_location, &event_location,
event_start, 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); 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 // Save to localStorage
self.save_alarms_to_storage(); 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 /// Create a scheduled alarm from a VAlarm
@@ -245,8 +185,6 @@ impl AlarmScheduler {
// Also close any active notifications for this event // Also close any active notifications for this event
self.notification_manager.close_notification(event_uid); self.notification_manager.close_notification(event_uid);
web_sys::console::log_1(&format!("Removed alarms for event: {}", event_uid).into());
// Save to localStorage // Save to localStorage
self.save_alarms_to_storage(); self.save_alarms_to_storage();
@@ -260,61 +198,24 @@ impl AlarmScheduler {
let now = Local::now().naive_local(); let now = Local::now().naive_local();
let mut triggered_count = 0; 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) // Find alarms that should trigger (within 30 seconds tolerance)
let alarms_to_trigger: Vec<ScheduledAlarm> = self.scheduled_alarms let alarms_to_trigger: Vec<ScheduledAlarm> = self.scheduled_alarms
.values() .values()
.filter(|alarm| { .filter(|alarm| {
let should_trigger = alarm.status == AlarmStatus::Pending && alarm.status == AlarmStatus::Pending &&
alarm.trigger_time <= now + Duration::seconds(30) && alarm.trigger_time <= now + Duration::seconds(30) &&
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() .cloned()
.collect(); .collect();
web_sys::console::log_1(
&format!("🔔 DEBUG: Found {} alarms to trigger", alarms_to_trigger.len()).into()
);
for alarm in alarms_to_trigger { 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) { if self.trigger_alarm(&alarm) {
// Mark alarm as triggered // Mark alarm as triggered
if let Some(scheduled_alarm) = self.scheduled_alarms.get_mut(&alarm.id) { if let Some(scheduled_alarm) = self.scheduled_alarms.get_mut(&alarm.id) {
scheduled_alarm.status = AlarmStatus::Triggered; scheduled_alarm.status = AlarmStatus::Triggered;
} }
triggered_count += 1; 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()
);
} }
} }
@@ -331,21 +232,8 @@ impl AlarmScheduler {
/// Trigger a specific alarm /// Trigger a specific alarm
fn trigger_alarm(&mut self, alarm: &ScheduledAlarm) -> bool { 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 // Don't trigger if already showing notification for this event
if self.notification_manager.has_notification(&alarm.event_uid) { 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; return false;
} }
@@ -356,20 +244,11 @@ impl AlarmScheduler {
alarm_time: alarm.event_start, 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) { match self.notification_manager.show_alarm_notification(alarm_notification) {
Ok(()) => { Ok(()) => true,
web_sys::console::log_1(
&format!("✅ Triggered alarm for: {}", alarm.event_summary).into()
);
true
}
Err(err) => { Err(err) => {
web_sys::console::error_1( web_sys::console::error_1(
&format!("❌ Failed to trigger alarm: {:?}", err).into() &format!("Failed to trigger alarm: {:?}", err).into()
); );
false false
} }

76
frontend/src/services/notification_manager.rs
View File

@@ -30,21 +30,14 @@ impl NotificationManager {
if let Some(window) = window() { if let Some(window) = window() {
let has_notification = js_sys::Reflect::has(&window, &"Notification".into()).unwrap_or(false); let has_notification = js_sys::Reflect::has(&window, &"Notification".into()).unwrap_or(false);
// Additional debugging - try to access Notification directly via JsValue // Additional check - try to access Notification directly via JsValue
let window_js: &wasm_bindgen::JsValue = window.as_ref(); 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 direct_check = js_sys::Reflect::get(window_js, &"Notification".into()).unwrap_or(wasm_bindgen::JsValue::UNDEFINED);
let has_direct = !direct_check.is_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 // Use either check
let result = has_notification || has_direct; has_notification || has_direct
result
} else { } else {
web_sys::console::log_1(&"🔔 DEBUG: No window object available".into());
false false
} }
} }
@@ -60,109 +53,63 @@ impl NotificationManager {
/// Force request notification permission (even if previously denied) /// Force request notification permission (even if previously denied)
pub async fn force_request_permission() -> Result<NotificationPermission, JsValue> { pub async fn force_request_permission() -> Result<NotificationPermission, JsValue> {
web_sys::console::log_1(&"🔔 DEBUG: force_request_permission called".into());
if !Self::is_supported() { if !Self::is_supported() {
web_sys::console::log_1(&"🔔 DEBUG: Notifications not supported".into());
return Ok(NotificationPermission::Denied); return Ok(NotificationPermission::Denied);
} }
// Always request permission, regardless of current status // 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 promise = Notification::request_permission()?;
let js_value = JsFuture::from(promise).await?; 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 // Convert JS string back to NotificationPermission
if let Some(permission_str) = js_value.as_string() { if let Some(permission_str) = js_value.as_string() {
let result = match permission_str.as_str() { match permission_str.as_str() {
"granted" => Ok(NotificationPermission::Granted), "granted" => Ok(NotificationPermission::Granted),
"denied" => Ok(NotificationPermission::Denied), "denied" => Ok(NotificationPermission::Denied),
_ => Ok(NotificationPermission::Default), _ => Ok(NotificationPermission::Default),
}; }
web_sys::console::log_1(
&format!("🔔 DEBUG: Force returning permission: {:?}", result).into()
);
result
} else { } else {
web_sys::console::log_1(&"🔔 DEBUG: Force permission result was not a string, returning Denied".into());
Ok(NotificationPermission::Denied) Ok(NotificationPermission::Denied)
} }
} }
/// Request notification permission from the user /// Request notification permission from the user
pub async fn request_permission() -> Result<NotificationPermission, JsValue> { pub async fn request_permission() -> Result<NotificationPermission, JsValue> {
web_sys::console::log_1(&"🔔 DEBUG: request_permission called".into());
if !Self::is_supported() { if !Self::is_supported() {
web_sys::console::log_1(&"🔔 DEBUG: Notifications not supported".into());
return Ok(NotificationPermission::Denied); return Ok(NotificationPermission::Denied);
} }
// Check current permission status // Check current permission status
let current_permission = Notification::permission(); let current_permission = Notification::permission();
web_sys::console::log_1(
&format!("🔔 DEBUG: Current permission status: {:?}", current_permission).into()
);
if current_permission != NotificationPermission::Default { 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); return Ok(current_permission);
} }
// Request permission // Request permission
web_sys::console::log_1(&"🔔 DEBUG: Calling Notification::request_permission()".into());
let promise = Notification::request_permission()?; let promise = Notification::request_permission()?;
let js_value = JsFuture::from(promise).await?; 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 // Convert JS string back to NotificationPermission
if let Some(permission_str) = js_value.as_string() { if let Some(permission_str) = js_value.as_string() {
let result = match permission_str.as_str() { match permission_str.as_str() {
"granted" => Ok(NotificationPermission::Granted), "granted" => Ok(NotificationPermission::Granted),
"denied" => Ok(NotificationPermission::Denied), "denied" => Ok(NotificationPermission::Denied),
_ => Ok(NotificationPermission::Default), _ => Ok(NotificationPermission::Default),
}; }
web_sys::console::log_1(
&format!("🔔 DEBUG: Returning permission: {:?}", result).into()
);
result
} else { } else {
web_sys::console::log_1(&"🔔 DEBUG: Permission result was not a string, returning Denied".into());
Ok(NotificationPermission::Denied) Ok(NotificationPermission::Denied)
} }
} }
/// Display a notification for an alarm /// Display a notification for an alarm
pub fn show_alarm_notification(&mut self, alarm: AlarmNotification) -> Result<(), JsValue> { 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 // Check permission
let permission = Self::get_permission(); if Self::get_permission() != NotificationPermission::Granted {
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 return Ok(()); // Don't error, just skip
} }
// Check if notification already exists for this event // Check if notification already exists for this event
if self.active_notifications.contains_key(&alarm.event_uid) { 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 return Ok(()); // Already showing notification for this event
} }
@@ -190,14 +137,8 @@ impl NotificationManager {
options.set_require_interaction(true); options.set_require_interaction(true);
// Create and show notification // 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)?; 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 // Store reference to track active notifications
self.active_notifications.insert(alarm.event_uid.clone(), notification.clone()); self.active_notifications.insert(alarm.event_uid.clone(), notification.clone());
@@ -209,7 +150,6 @@ impl NotificationManager {
let _ = window.focus(); let _ = window.focus();
} }
web_sys::console::log_1(&format!("Notification clicked for event: {}", event_uid).into());
}) as Box<dyn FnMut(_)>); }) as Box<dyn FnMut(_)>);
notification.set_onclick(Some(onclick_closure.as_ref().unchecked_ref())); notification.set_onclick(Some(onclick_closure.as_ref().unchecked_ref()));
@@ -225,8 +165,6 @@ impl NotificationManager {
notification.set_onclose(Some(onclose_closure.as_ref().unchecked_ref())); notification.set_onclose(Some(onclose_closure.as_ref().unchecked_ref()));
onclose_closure.forget(); // Keep closure alive onclose_closure.forget(); // Keep closure alive
web_sys::console::log_1(&format!("Displayed notification for: {}", alarm.event_summary).into());
Ok(()) Ok(())
} }