diff --git a/backend/src/auth.rs b/backend/src/auth.rs
index 0cf8841..7f128e7 100644
--- a/backend/src/auth.rs
+++ b/backend/src/auth.rs
@@ -2,16 +2,16 @@ use chrono::{Duration, Utc};
 use jsonwebtoken::{decode, encode, Algorithm, DecodingKey, EncodingKey, Header, Validation};
 use serde::{Deserialize, Serialize};
 
-use crate::models::{CalDAVLoginRequest, AuthResponse, ApiError};
-use crate::config::CalDAVConfig;
 use crate::calendar::CalDAVClient;
+use crate::config::CalDAVConfig;
+use crate::models::{ApiError, AuthResponse, CalDAVLoginRequest};
 
 #[derive(Debug, Serialize, Deserialize)]
 pub struct Claims {
     pub username: String,
     pub server_url: String,
-    pub exp: i64,     // Expiration time
-    pub iat: i64,     // Issued at
+    pub exp: i64, // Expiration time
+    pub iat: i64, // Issued at
 }
 
 #[derive(Clone)]
@@ -33,22 +33,25 @@ impl AuthService {
         // Create CalDAV config with provided credentials
         let caldav_config = CalDAVConfig::new(
             request.server_url.clone(),
-            request.username.clone(), 
-            request.password.clone()
+            request.username.clone(),
+            request.password.clone(),
         );
         println!("📝 Created CalDAV config");
 
         // Test authentication against CalDAV server
         let caldav_client = CalDAVClient::new(caldav_config.clone());
         println!("🔗 Created CalDAV client, attempting to discover calendars...");
-        
+
         // Try to discover calendars as an authentication test
         match caldav_client.discover_calendars().await {
             Ok(calendars) => {
-                println!("✅ Authentication successful! Found {} calendars", calendars.len());
+                println!(
+                    "✅ Authentication successful! Found {} calendars",
+                    calendars.len()
+                );
                 // Authentication successful, generate JWT token
                 let token = self.generate_token(&request.username, &request.server_url)?;
-                
+
                 Ok(AuthResponse {
                     token,
                     username: request.username,
@@ -58,7 +61,9 @@ impl AuthService {
             Err(err) => {
                 println!("❌ Authentication failed: {:?}", err);
                 // Authentication failed
-                Err(ApiError::Unauthorized("Invalid CalDAV credentials or server unavailable".to_string()))
+                Err(ApiError::Unauthorized(
+                    "Invalid CalDAV credentials or server unavailable".to_string(),
+                ))
             }
         }
     }
@@ -69,13 +74,17 @@ impl AuthService {
     }
 
     /// Create CalDAV config from token
-    pub fn caldav_config_from_token(&self, token: &str, password: &str) -> Result<CalDAVConfig, ApiError> {
+    pub fn caldav_config_from_token(
+        &self,
+        token: &str,
+        password: &str,
+    ) -> Result<CalDAVConfig, ApiError> {
         let claims = self.verify_token(token)?;
-        
+
         Ok(CalDAVConfig::new(
             claims.server_url,
-            claims.username, 
-            password.to_string()
+            claims.username,
+            password.to_string(),
         ))
     }
 
@@ -93,8 +102,11 @@ impl AuthService {
         }
 
         // Basic URL validation
-        if !request.server_url.starts_with("http://") && !request.server_url.starts_with("https://") {
-            return Err(ApiError::BadRequest("Server URL must start with http:// or https://".to_string()));
+        if !request.server_url.starts_with("http://") && !request.server_url.starts_with("https://")
+        {
+            return Err(ApiError::BadRequest(
+                "Server URL must start with http:// or https://".to_string(),
+            ));
         }
 
         Ok(())
@@ -131,4 +143,4 @@ impl AuthService {
 
         Ok(token_data.claims)
     }
-}
\ No newline at end of file
+}
diff --git a/backend/src/calendar.rs b/backend/src/calendar.rs
index 6c6cecc..c157697 100644
--- a/backend/src/calendar.rs
+++ b/backend/src/calendar.rs
@@ -1,9 +1,9 @@
+use calendar_models::{CalendarUser, EventClass, EventStatus, VAlarm, VEvent};
 use chrono::{DateTime, Utc};
 use serde::{Deserialize, Serialize};
 use std::collections::HashMap;
 use std::sync::Arc;
 use tokio::sync::Mutex;
-use calendar_models::{VEvent, EventStatus, EventClass, CalendarUser, VAlarm};
 
 // Global mutex to serialize CalDAV HTTP requests to prevent race conditions
 lazy_static::lazy_static! {
@@ -18,64 +18,64 @@ pub type CalendarEvent = VEvent;
 pub struct OldCalendarEvent {
     /// Unique identifier for the event (UID field in iCal)
     pub uid: String,
-    
+
     /// Summary/title of the event
     pub summary: Option<String>,
-    
+
     /// Detailed description of the event
     pub description: Option<String>,
-    
+
     /// Start date and time of the event
     pub start: DateTime<Utc>,
-    
+
     /// End date and time of the event
     pub end: Option<DateTime<Utc>>,
-    
+
     /// Location where the event takes place
     pub location: Option<String>,
-    
+
     /// Event status (TENTATIVE, CONFIRMED, CANCELLED)
     pub status: EventStatus,
-    
+
     /// Event classification (PUBLIC, PRIVATE, CONFIDENTIAL)
     pub class: EventClass,
-    
+
     /// Event priority (0-9, where 0 is undefined, 1 is highest, 9 is lowest)
     pub priority: Option<u8>,
-    
+
     /// Organizer of the event
     pub organizer: Option<String>,
-    
+
     /// List of attendees
     pub attendees: Vec<String>,
-    
+
     /// Categories/tags for the event
     pub categories: Vec<String>,
-    
+
     /// Date and time when the event was created
     pub created: Option<DateTime<Utc>>,
-    
+
     /// Date and time when the event was last modified
     pub last_modified: Option<DateTime<Utc>>,
-    
+
     /// Recurrence rule (RRULE)
     pub recurrence_rule: Option<String>,
-    
+
     /// Exception dates - dates to exclude from recurrence (EXDATE)
     pub exdate: Vec<DateTime<Utc>>,
-    
+
     /// All-day event flag
     pub all_day: bool,
-    
+
     /// Reminders/alarms for this event
     pub reminders: Vec<EventReminder>,
-    
+
     /// ETag from CalDAV server for conflict detection
     pub etag: Option<String>,
-    
+
     /// URL/href of this event on the CalDAV server
     pub href: Option<String>,
-    
+
     /// Calendar path this event belongs to
     pub calendar_path: Option<String>,
 }
@@ -87,10 +87,10 @@ pub struct OldCalendarEvent {
 pub struct EventReminder {
     /// How long before the event to trigger the reminder (in minutes)
     pub minutes_before: i32,
-    
+
     /// Type of reminder action
     pub action: ReminderAction,
-    
+
     /// Optional description for the reminder
     pub description: Option<String>,
 }
@@ -117,7 +117,7 @@ impl CalDAVClient {
             .timeout(std::time::Duration::from_secs(60)) // 60 second global timeout
             .build()
             .expect("Failed to create HTTP client");
-            
+
         Self {
             config,
             http_client,
@@ -125,10 +125,13 @@ impl CalDAVClient {
     }
 
     /// Fetch calendar events from the CalDAV server
-    /// 
+    ///
     /// This method performs a REPORT request to get calendar data and parses
     /// the returned iCalendar format into CalendarEvent structs.
-    pub async fn fetch_events(&self, calendar_path: &str) -> Result<Vec<CalendarEvent>, CalDAVError> {
+    pub async fn fetch_events(
+        &self,
+        calendar_path: &str,
+    ) -> Result<Vec<CalendarEvent>, CalDAVError> {
         // CalDAV REPORT request to get calendar events
         let report_body = r#"<?xml version="1.0" encoding="utf-8" ?>
 <c:calendar-query xmlns:d="DAV:" xmlns:c="urn:ietf:params:xml:ns:caldav">
@@ -149,7 +152,11 @@ impl CalDAVClient {
             // Extract the base URL (scheme + host + port) from server_url
             let server_url = &self.config.server_url;
             // Find the first '/' after "https://" or "http://"
-            let scheme_end = if server_url.starts_with("https://") { 8 } else { 7 };
+            let scheme_end = if server_url.starts_with("https://") {
+                8
+            } else {
+                7
+            };
             if let Some(path_start) = server_url[scheme_end..].find('/') {
                 let base_url = &server_url[..scheme_end + path_start];
                 format!("{}{}", base_url, calendar_path)
@@ -162,8 +169,9 @@ impl CalDAVClient {
         let basic_auth = self.config.get_basic_auth();
         println!("🔑 REPORT Basic Auth: Basic {}", basic_auth);
         println!("🌐 REPORT URL: {}", url);
-        
-        let response = self.http_client
+
+        let response = self
+            .http_client
             .request(reqwest::Method::from_bytes(b"REPORT").unwrap(), &url)
             .header("Authorization", format!("Basic {}", basic_auth))
             .header("Content-Type", "application/xml")
@@ -183,13 +191,17 @@ impl CalDAVClient {
     }
 
     /// Parse CalDAV XML response containing calendar data
-    fn parse_calendar_response(&self, xml_response: &str, calendar_path: &str) -> Result<Vec<CalendarEvent>, CalDAVError> {
+    fn parse_calendar_response(
+        &self,
+        xml_response: &str,
+        calendar_path: &str,
+    ) -> Result<Vec<CalendarEvent>, CalDAVError> {
         let mut events = Vec::new();
-        
+
         // Extract calendar data from XML response
         // This is a simplified parser - in production, you'd want a proper XML parser
         let calendar_data_sections = self.extract_calendar_data(xml_response);
-        
+
         for calendar_data in calendar_data_sections {
             if let Ok(parsed_events) = self.parse_ical_data(&calendar_data.data) {
                 for mut event in parsed_events {
@@ -205,30 +217,40 @@ impl CalDAVClient {
     }
 
     /// Fetch a single calendar event by UID from the CalDAV server
-    pub async fn fetch_event_by_uid(&self, calendar_path: &str, uid: &str) -> Result<Option<CalendarEvent>, CalDAVError> {
+    pub async fn fetch_event_by_uid(
+        &self,
+        calendar_path: &str,
+        uid: &str,
+    ) -> Result<Option<CalendarEvent>, CalDAVError> {
         // First fetch all events and find the one with matching UID
         let events = self.fetch_events(calendar_path).await?;
-        
+
         // Find event with matching UID
         let event = events.into_iter().find(|e| e.uid == uid);
-        
+
         Ok(event)
     }
 
     /// Extract calendar data sections from CalDAV XML response
     fn extract_calendar_data(&self, xml_response: &str) -> Vec<CalendarDataSection> {
         let mut sections = Vec::new();
-        
+
         // Simple regex-based extraction (in production, use a proper XML parser)
         // Look for <d:response> blocks containing calendar data
         for response_block in xml_response.split("<d:response>").skip(1) {
             if let Some(end_pos) = response_block.find("</d:response>") {
                 let response_content = &response_block[..end_pos];
-                
-                let href = self.extract_xml_content(response_content, "href").unwrap_or_default();
-                let etag = self.extract_xml_content(response_content, "getetag").unwrap_or_default();
-                
-                if let Some(calendar_data) = self.extract_xml_content(response_content, "cal:calendar-data") {
+
+                let href = self
+                    .extract_xml_content(response_content, "href")
+                    .unwrap_or_default();
+                let etag = self
+                    .extract_xml_content(response_content, "getetag")
+                    .unwrap_or_default();
+
+                if let Some(calendar_data) =
+                    self.extract_xml_content(response_content, "cal:calendar-data")
+                {
                     sections.push(CalendarDataSection {
                         href: if href.is_empty() { None } else { Some(href) },
                         etag: if etag.is_empty() { None } else { Some(etag) },
@@ -237,7 +259,7 @@ impl CalDAVClient {
                 }
             }
         }
-        
+
         sections
     }
 
@@ -245,14 +267,30 @@ impl CalDAVClient {
     fn extract_xml_content(&self, xml: &str, tag: &str) -> Option<String> {
         // Handle both with and without namespace prefixes
         let patterns = [
-            format!("(?s)<{}>(.*?)</{}>", tag, tag),                    // <tag>content</tag>
-            format!("(?s)<{}>(.*?)</.*:{}>", tag, tag.split(':').last().unwrap_or(tag)),  // <tag>content</ns:tag>
-            format!("(?s)<.*:{}>(.*?)</{}>", tag.split(':').last().unwrap_or(tag), tag), // <ns:tag>content</tag>
-            format!("(?s)<.*:{}>(.*?)</.*:{}>", tag.split(':').last().unwrap_or(tag), tag.split(':').last().unwrap_or(tag)), // <ns:tag>content</ns:tag>
-            format!("(?s)<{}[^>]*>(.*?)</{}>", tag, tag),               // <tag attr>content</tag>
-            format!("(?s)<{}[^>]*>(.*?)</.*:{}>", tag, tag.split(':').last().unwrap_or(tag)),
+            format!("(?s)<{}>(.*?)</{}>", tag, tag), // <tag>content</tag>
+            format!(
+                "(?s)<{}>(.*?)</.*:{}>",
+                tag,
+                tag.split(':').last().unwrap_or(tag)
+            ), // <tag>content</ns:tag>
+            format!(
+                "(?s)<.*:{}>(.*?)</{}>",
+                tag.split(':').last().unwrap_or(tag),
+                tag
+            ), // <ns:tag>content</tag>
+            format!(
+                "(?s)<.*:{}>(.*?)</.*:{}>",
+                tag.split(':').last().unwrap_or(tag),
+                tag.split(':').last().unwrap_or(tag)
+            ), // <ns:tag>content</ns:tag>
+            format!("(?s)<{}[^>]*>(.*?)</{}>", tag, tag), // <tag attr>content</tag>
+            format!(
+                "(?s)<{}[^>]*>(.*?)</.*:{}>",
+                tag,
+                tag.split(':').last().unwrap_or(tag)
+            ),
         ];
-        
+
         for pattern in &patterns {
             if let Ok(re) = regex::Regex::new(pattern) {
                 if let Some(captures) = re.captures(xml) {
@@ -262,46 +300,54 @@ impl CalDAVClient {
                 }
             }
         }
-        
+
         None
     }
 
     /// Parse iCalendar data into CalendarEvent structs
     fn parse_ical_data(&self, ical_data: &str) -> Result<Vec<CalendarEvent>, CalDAVError> {
         let mut events = Vec::new();
-        
+
         // Parse the iCal data using the ical crate
         let reader = ical::IcalParser::new(ical_data.as_bytes());
-        
+
         for calendar in reader {
             let calendar = calendar.map_err(|e| CalDAVError::ParseError(e.to_string()))?;
-            
+
             for event in calendar.events {
                 if let Ok(calendar_event) = self.parse_ical_event(event) {
                     events.push(calendar_event);
                 }
             }
         }
-        
+
         Ok(events)
     }
 
     /// Parse a single iCal event into a CalendarEvent struct
-    fn parse_ical_event(&self, event: ical::parser::ical::component::IcalEvent) -> Result<CalendarEvent, CalDAVError> {
+    fn parse_ical_event(
+        &self,
+        event: ical::parser::ical::component::IcalEvent,
+    ) -> Result<CalendarEvent, CalDAVError> {
         let mut properties: HashMap<String, String> = HashMap::new();
-        
+
         // Extract all properties from the event
         for property in &event.properties {
-            properties.insert(property.name.to_uppercase(), property.value.clone().unwrap_or_default());
+            properties.insert(
+                property.name.to_uppercase(),
+                property.value.clone().unwrap_or_default(),
+            );
         }
 
         // Required UID field
-        let uid = properties.get("UID")
+        let uid = properties
+            .get("UID")
             .ok_or_else(|| CalDAVError::ParseError("Missing UID field".to_string()))?
             .clone();
 
         // Parse start time (required)
-        let start = properties.get("DTSTART")
+        let start = properties
+            .get("DTSTART")
             .ok_or_else(|| CalDAVError::ParseError("Missing DTSTART field".to_string()))?;
         let start = self.parse_datetime(start, properties.get("DTSTART"))?;
 
@@ -316,12 +362,14 @@ impl CalDAVClient {
         };
 
         // Determine if it's an all-day event
-        let all_day = properties.get("DTSTART")
+        let all_day = properties
+            .get("DTSTART")
             .map(|s| !s.contains("T"))
             .unwrap_or(false);
 
         // Parse status
-        let status = properties.get("STATUS")
+        let status = properties
+            .get("STATUS")
             .map(|s| match s.to_uppercase().as_str() {
                 "TENTATIVE" => EventStatus::Tentative,
                 "CANCELLED" => EventStatus::Cancelled,
@@ -330,7 +378,8 @@ impl CalDAVClient {
             .unwrap_or(EventStatus::Confirmed);
 
         // Parse classification
-        let class = properties.get("CLASS")
+        let class = properties
+            .get("CLASS")
             .map(|s| match s.to_uppercase().as_str() {
                 "PRIVATE" => EventClass::Private,
                 "CONFIDENTIAL" => EventClass::Confidential,
@@ -339,20 +388,24 @@ impl CalDAVClient {
             .unwrap_or(EventClass::Public);
 
         // Parse priority
-        let priority = properties.get("PRIORITY")
+        let priority = properties
+            .get("PRIORITY")
             .and_then(|s| s.parse::<u8>().ok())
             .filter(|&p| p <= 9);
 
         // Parse categories
-        let categories = properties.get("CATEGORIES")
+        let categories = properties
+            .get("CATEGORIES")
             .map(|s| s.split(',').map(|c| c.trim().to_string()).collect())
             .unwrap_or_default();
 
         // Parse dates
-        let created = properties.get("CREATED")
+        let created = properties
+            .get("CREATED")
             .and_then(|s| self.parse_datetime(s, None).ok());
-        
-        let last_modified = properties.get("LAST-MODIFIED")
+
+        let last_modified = properties
+            .get("LAST-MODIFIED")
             .and_then(|s| self.parse_datetime(s, None).ok());
 
         // Parse exception dates (EXDATE)
@@ -360,7 +413,7 @@ impl CalDAVClient {
 
         // Create VEvent with required fields
         let mut vevent = VEvent::new(uid, start);
-        
+
         // Set optional fields
         vevent.dtend = end;
         vevent.summary = properties.get("SUMMARY").cloned();
@@ -369,7 +422,7 @@ impl CalDAVClient {
         vevent.status = Some(status);
         vevent.class = Some(class);
         vevent.priority = priority;
-        
+
         // Convert organizer string to CalendarUser
         if let Some(organizer_str) = properties.get("ORGANIZER") {
             vevent.organizer = Some(CalendarUser {
@@ -380,59 +433,72 @@ impl CalDAVClient {
                 language: None,
             });
         }
-        
+
         // TODO: Parse attendees properly
         vevent.attendees = Vec::new();
-        
+
         vevent.categories = categories;
         vevent.created = created;
         vevent.last_modified = last_modified;
         vevent.rrule = properties.get("RRULE").cloned();
         vevent.exdate = exdate;
         vevent.all_day = all_day;
-        
+
         // Parse alarms
         vevent.alarms = self.parse_valarms(&event)?;
-        
+
         // CalDAV specific fields (set by caller)
         vevent.etag = None;
         vevent.href = None;
         vevent.calendar_path = None;
-        
+
         Ok(vevent)
     }
 
     /// Parse VALARM components from an iCal event
-    fn parse_valarms(&self, event: &ical::parser::ical::component::IcalEvent) -> Result<Vec<VAlarm>, CalDAVError> {
+    fn parse_valarms(
+        &self,
+        event: &ical::parser::ical::component::IcalEvent,
+    ) -> Result<Vec<VAlarm>, CalDAVError> {
         let mut alarms = Vec::new();
-        
+
         for alarm in &event.alarms {
             if let Ok(valarm) = self.parse_single_valarm(alarm) {
                 alarms.push(valarm);
             }
         }
-        
+
         Ok(alarms)
     }
 
     /// Parse a single VALARM component into a VAlarm
-    fn parse_single_valarm(&self, alarm: &ical::parser::ical::component::IcalAlarm) -> Result<VAlarm, CalDAVError> {
+    fn parse_single_valarm(
+        &self,
+        alarm: &ical::parser::ical::component::IcalAlarm,
+    ) -> Result<VAlarm, CalDAVError> {
         let mut properties: HashMap<String, String> = HashMap::new();
-        
+
         // Extract all properties from the alarm
         for property in &alarm.properties {
-            properties.insert(property.name.to_uppercase(), property.value.clone().unwrap_or_default());
+            properties.insert(
+                property.name.to_uppercase(),
+                property.value.clone().unwrap_or_default(),
+            );
         }
-        
+
         // Parse ACTION (required)
         let action = match properties.get("ACTION").map(|s| s.to_uppercase()) {
-            Some(ref action_str) if action_str == "DISPLAY" => calendar_models::AlarmAction::Display,
+            Some(ref action_str) if action_str == "DISPLAY" => {
+                calendar_models::AlarmAction::Display
+            }
             Some(ref action_str) if action_str == "EMAIL" => calendar_models::AlarmAction::Email,
             Some(ref action_str) if action_str == "AUDIO" => calendar_models::AlarmAction::Audio,
-            Some(ref action_str) if action_str == "PROCEDURE" => calendar_models::AlarmAction::Procedure,
+            Some(ref action_str) if action_str == "PROCEDURE" => {
+                calendar_models::AlarmAction::Procedure
+            }
             _ => calendar_models::AlarmAction::Display, // Default
         };
-        
+
         // Parse TRIGGER (required)
         let trigger = if let Some(trigger_str) = properties.get("TRIGGER") {
             if let Some(minutes) = self.parse_trigger_duration(trigger_str) {
@@ -445,10 +511,10 @@ impl CalDAVClient {
             // Default to 15 minutes before
             calendar_models::AlarmTrigger::Duration(chrono::Duration::minutes(-15))
         };
-        
+
         // Get description
         let description = properties.get("DESCRIPTION").cloned();
-        
+
         Ok(VAlarm {
             action,
             trigger,
@@ -465,18 +531,18 @@ impl CalDAVClient {
     fn parse_trigger_duration(&self, trigger: &str) -> Option<i32> {
         // Basic parsing of ISO 8601 duration or relative time
         // Examples: "-PT15M" (15 minutes before), "-P1D" (1 day before)
-        
+
         if trigger.starts_with("-PT") && trigger.ends_with("M") {
             // Parse "-PT15M" format (minutes)
-            let minutes_str = &trigger[3..trigger.len()-1];
+            let minutes_str = &trigger[3..trigger.len() - 1];
             minutes_str.parse::<i32>().ok()
         } else if trigger.starts_with("-PT") && trigger.ends_with("H") {
             // Parse "-PT1H" format (hours)
-            let hours_str = &trigger[3..trigger.len()-1];
+            let hours_str = &trigger[3..trigger.len() - 1];
             hours_str.parse::<i32>().ok().map(|h| h * 60)
         } else if trigger.starts_with("-P") && trigger.ends_with("D") {
             // Parse "-P1D" format (days)
-            let days_str = &trigger[2..trigger.len()-1];
+            let days_str = &trigger[2..trigger.len() - 1];
             days_str.parse::<i32>().ok().map(|d| d * 24 * 60)
         } else {
             // Try to parse as raw minutes
@@ -491,17 +557,14 @@ impl CalDAVClient {
             println!("Using configured calendar path: {}", calendar_path);
             return Ok(vec![calendar_path.clone()]);
         }
-        
+
         println!("No calendar path configured, discovering calendars...");
 
         // Try different common CalDAV discovery paths
         // Note: paths should be relative to the server URL base
         let user_calendar_path = format!("/calendars/{}/", self.config.username);
-        
-        let discovery_paths = vec![
-            "/calendars/",
-            user_calendar_path.as_str(),
-        ];
+
+        let discovery_paths = vec!["/calendars/", user_calendar_path.as_str()];
 
         let mut all_calendars = Vec::new();
 
@@ -533,9 +596,13 @@ impl CalDAVClient {
 
         let url = format!("{}{}", self.config.server_url.trim_end_matches('/'), path);
 
-        let response = self.http_client
+        let response = self
+            .http_client
             .request(reqwest::Method::from_bytes(b"PROPFIND").unwrap(), &url)
-            .header("Authorization", format!("Basic {}", self.config.get_basic_auth()))
+            .header(
+                "Authorization",
+                format!("Basic {}", self.config.get_basic_auth()),
+            )
             .header("Content-Type", "application/xml")
             .header("Depth", "2") // Deeper search to find actual calendars
             .header("User-Agent", "calendar-app/0.1.0")
@@ -545,39 +612,50 @@ impl CalDAVClient {
             .map_err(CalDAVError::RequestError)?;
 
         if response.status().as_u16() != 207 {
-            println!("❌ Discovery PROPFIND failed for {}: HTTP {}", path, response.status().as_u16());
+            println!(
+                "❌ Discovery PROPFIND failed for {}: HTTP {}",
+                path,
+                response.status().as_u16()
+            );
             return Err(CalDAVError::ServerError(response.status().as_u16()));
         }
 
         let body = response.text().await.map_err(CalDAVError::RequestError)?;
         println!("Discovery response for {}: {}", path, body);
-        
+
         let mut calendar_paths = Vec::new();
-        
+
         // Extract calendar collection URLs from the response
         for response_block in body.split("<d:response>").skip(1) {
             if let Some(end_pos) = response_block.find("</d:response>") {
                 let response_content = &response_block[..end_pos];
-                
+
                 // Extract href first
                 if let Some(href) = self.extract_xml_content(response_content, "href") {
                     println!("🔍 Checking resource: {}", href);
-                    
+
                     // Check if this is a calendar collection by looking for supported-calendar-component-set
                     // This indicates it's an actual calendar that can contain events
-                    let has_supported_components = response_content.contains("supported-calendar-component-set") &&
-                                                  (response_content.contains("VEVENT") || response_content.contains("VTODO"));
-                    let has_calendar_resourcetype = response_content.contains("<cal:calendar") || response_content.contains("<c:calendar");
-                    
+                    let has_supported_components = response_content
+                        .contains("supported-calendar-component-set")
+                        && (response_content.contains("VEVENT")
+                            || response_content.contains("VTODO"));
+                    let has_calendar_resourcetype = response_content.contains("<cal:calendar")
+                        || response_content.contains("<c:calendar");
+
                     let is_calendar = has_supported_components || has_calendar_resourcetype;
-                    
+
                     // Also check resourcetype for collection
-                    let has_collection = response_content.contains("<d:collection") || response_content.contains("<collection");
-                    
+                    let has_collection = response_content.contains("<d:collection")
+                        || response_content.contains("<collection");
+
                     if is_calendar && has_collection {
                         // Exclude system directories like inbox, outbox, and root calendar directories
-                        if !href.contains("/inbox/") && !href.contains("/outbox/") && 
-                           !href.ends_with("/calendars/") && href.ends_with('/') {
+                        if !href.contains("/inbox/")
+                            && !href.contains("/outbox/")
+                            && !href.ends_with("/calendars/")
+                            && href.ends_with('/')
+                        {
                             println!("📅 Found calendar collection: {}", href);
                             calendar_paths.push(href);
                         } else {
@@ -590,24 +668,28 @@ impl CalDAVClient {
                 }
             }
         }
-        
+
         Ok(calendar_paths)
     }
 
     /// Parse iCal datetime format
-    fn parse_datetime(&self, datetime_str: &str, _original_property: Option<&String>) -> Result<DateTime<Utc>, CalDAVError> {
+    fn parse_datetime(
+        &self,
+        datetime_str: &str,
+        _original_property: Option<&String>,
+    ) -> Result<DateTime<Utc>, CalDAVError> {
         use chrono::TimeZone;
-        
+
         // Handle different iCal datetime formats
         let cleaned = datetime_str.replace("TZID=", "").trim().to_string();
-        
+
         // Try different parsing formats
         let formats = [
-            "%Y%m%dT%H%M%SZ",        // UTC format: 20231225T120000Z
-            "%Y%m%dT%H%M%S",         // Local format: 20231225T120000
-            "%Y%m%d",                // Date only: 20231225
+            "%Y%m%dT%H%M%SZ", // UTC format: 20231225T120000Z
+            "%Y%m%dT%H%M%S",  // Local format: 20231225T120000
+            "%Y%m%d",         // Date only: 20231225
         ];
-        
+
         for format in &formats {
             if let Ok(dt) = chrono::NaiveDateTime::parse_from_str(&cleaned, format) {
                 return Ok(Utc.from_utc_datetime(&dt));
@@ -616,14 +698,17 @@ impl CalDAVClient {
                 return Ok(Utc.from_utc_datetime(&date.and_hms_opt(0, 0, 0).unwrap()));
             }
         }
-        
-        Err(CalDAVError::ParseError(format!("Unable to parse datetime: {}", datetime_str)))
+
+        Err(CalDAVError::ParseError(format!(
+            "Unable to parse datetime: {}",
+            datetime_str
+        )))
     }
 
     /// Parse EXDATE properties from an iCal event
     fn parse_exdate(&self, event: &ical::parser::ical::component::IcalEvent) -> Vec<DateTime<Utc>> {
         let mut exdate = Vec::new();
-        
+
         // Look for EXDATE properties
         for property in &event.properties {
             if property.name.to_uppercase() == "EXDATE" {
@@ -638,35 +723,50 @@ impl CalDAVClient {
                 }
             }
         }
-        
+
         exdate
     }
 
     /// Create a new calendar on the CalDAV server using MKCALENDAR
-    pub async fn create_calendar(&self, name: &str, description: Option<&str>, color: Option<&str>) -> Result<(), CalDAVError> {
+    pub async fn create_calendar(
+        &self,
+        name: &str,
+        description: Option<&str>,
+        color: Option<&str>,
+    ) -> Result<(), CalDAVError> {
         // Sanitize calendar name for URL path
         let calendar_id = name
             .chars()
             .map(|c| if c.is_alphanumeric() { c } else { '-' })
             .collect::<String>()
             .to_lowercase();
-        
+
         let calendar_path = format!("/calendars/{}/{}/", self.config.username, calendar_id);
-        let full_url = format!("{}{}", self.config.server_url.trim_end_matches('/'), calendar_path);
-        
+        let full_url = format!(
+            "{}{}",
+            self.config.server_url.trim_end_matches('/'),
+            calendar_path
+        );
+
         // Build color property if provided
         let color_property = if let Some(color) = color {
-            format!(r#"<ic:calendar-color xmlns:ic="http://apple.com/ns/ical/">{}</ic:calendar-color>"#, color)
+            format!(
+                r#"<ic:calendar-color xmlns:ic="http://apple.com/ns/ical/">{}</ic:calendar-color>"#,
+                color
+            )
         } else {
             String::new()
         };
-        
+
         let description_property = if let Some(desc) = description {
-            format!(r#"<c:calendar-description xmlns:c="urn:ietf:params:xml:ns:caldav">{}</c:calendar-description>"#, desc)
+            format!(
+                r#"<c:calendar-description xmlns:c="urn:ietf:params:xml:ns:caldav">{}</c:calendar-description>"#,
+                desc
+            )
         } else {
             String::new()
         };
-        
+
         // Create the MKCALENDAR request body
         let mkcalendar_body = format!(
             r#"<?xml version="1.0" encoding="utf-8" ?>
@@ -684,21 +784,28 @@ impl CalDAVClient {
 </c:mkcalendar>"#,
             name, color_property, description_property
         );
-        
+
         println!("Creating calendar at: {}", full_url);
         println!("MKCALENDAR body: {}", mkcalendar_body);
-        
-        let response = self.http_client
-            .request(reqwest::Method::from_bytes(b"MKCALENDAR").unwrap(), &full_url)
+
+        let response = self
+            .http_client
+            .request(
+                reqwest::Method::from_bytes(b"MKCALENDAR").unwrap(),
+                &full_url,
+            )
             .header("Content-Type", "application/xml; charset=utf-8")
-            .header("Authorization", format!("Basic {}", self.config.get_basic_auth()))
+            .header(
+                "Authorization",
+                format!("Basic {}", self.config.get_basic_auth()),
+            )
             .body(mkcalendar_body)
             .send()
             .await
             .map_err(|e| CalDAVError::ParseError(e.to_string()))?;
 
         println!("Calendar creation response status: {}", response.status());
-        
+
         if response.status().is_success() {
             println!("✅ Calendar created successfully at {}", calendar_path);
             Ok(())
@@ -721,20 +828,28 @@ impl CalDAVClient {
             } else {
                 calendar_path
             };
-            format!("{}{}", self.config.server_url.trim_end_matches('/'), clean_path)
+            format!(
+                "{}{}",
+                self.config.server_url.trim_end_matches('/'),
+                clean_path
+            )
         };
-        
+
         println!("Deleting calendar at: {}", full_url);
-        
-        let response = self.http_client
+
+        let response = self
+            .http_client
             .delete(&full_url)
-            .header("Authorization", format!("Basic {}", self.config.get_basic_auth()))
+            .header(
+                "Authorization",
+                format!("Basic {}", self.config.get_basic_auth()),
+            )
             .send()
             .await
             .map_err(|e| CalDAVError::ParseError(e.to_string()))?;
 
         println!("Calendar deletion response status: {}", response.status());
-        
+
         if response.status().is_success() || response.status().as_u16() == 204 {
             println!("✅ Calendar deleted successfully at {}", calendar_path);
             Ok(())
@@ -747,24 +862,28 @@ impl CalDAVClient {
     }
 
     /// Create a new event in a CalDAV calendar
-    pub async fn create_event(&self, calendar_path: &str, event: &CalendarEvent) -> Result<String, CalDAVError> {
+    pub async fn create_event(
+        &self,
+        calendar_path: &str,
+        event: &CalendarEvent,
+    ) -> Result<String, CalDAVError> {
         // Generate a unique filename for the event (using UID + .ics extension)
         let event_filename = format!("{}.ics", event.uid);
-        
+
         // Construct the full URL for the event
         let full_url = if calendar_path.starts_with("http") {
             format!("{}/{}", calendar_path.trim_end_matches('/'), event_filename)
         } else {
             // Handle URL construction more carefully
             let server_url = self.config.server_url.trim_end_matches('/');
-            
+
             // Remove /dav.php from the end of server URL if present
             let base_url = if server_url.ends_with("/dav.php") {
                 server_url.trim_end_matches("/dav.php")
             } else {
                 server_url
             };
-            
+
             // Calendar path should start with /dav.php, if not add it
             let clean_calendar_path = if calendar_path.starts_with("/dav.php") {
                 calendar_path.trim_end_matches('/')
@@ -772,27 +891,31 @@ impl CalDAVClient {
                 // This shouldn't happen in our case, but handle it
                 &format!("/dav.php{}", calendar_path.trim_end_matches('/'))
             };
-            
+
             format!("{}{}/{}", base_url, clean_calendar_path, event_filename)
         };
-        
+
         println!("📝 Creating event with calendar_path: {}", calendar_path);
         println!("📝 Server URL: {}", self.config.server_url);
         println!("📝 Constructed URL: {}", full_url);
-        
+
         // Generate iCalendar data for the event
         let ical_data = self.generate_ical_event(event)?;
-        
+
         println!("Creating event at: {}", full_url);
         println!("iCal data: {}", ical_data);
-        
+
         println!("📡 Acquiring CalDAV HTTP lock for CREATE request...");
         let _lock = CALDAV_HTTP_MUTEX.lock().await;
         println!("📡 Lock acquired, sending CREATE request to CalDAV server...");
-        
-        let response = self.http_client
+
+        let response = self
+            .http_client
             .put(&full_url)
-            .header("Authorization", format!("Basic {}", self.config.get_basic_auth()))
+            .header(
+                "Authorization",
+                format!("Basic {}", self.config.get_basic_auth()),
+            )
             .header("Content-Type", "text/calendar; charset=utf-8")
             .header("User-Agent", "calendar-app/0.1.0")
             .body(ical_data)
@@ -801,7 +924,7 @@ impl CalDAVClient {
             .map_err(|e| CalDAVError::ParseError(e.to_string()))?;
 
         println!("Event creation response status: {}", response.status());
-        
+
         if response.status().is_success() || response.status().as_u16() == 201 {
             println!("✅ Event created successfully at {}", event_filename);
             Ok(event_filename)
@@ -814,13 +937,22 @@ impl CalDAVClient {
     }
 
     /// Update an existing event on the CalDAV server
-    pub async fn update_event(&self, calendar_path: &str, event: &CalendarEvent, event_href: &str) -> Result<(), CalDAVError> {
+    pub async fn update_event(
+        &self,
+        calendar_path: &str,
+        event: &CalendarEvent,
+        event_href: &str,
+    ) -> Result<(), CalDAVError> {
         // Construct the full URL for the event
         let full_url = if event_href.starts_with("http") {
             event_href.to_string()
         } else if event_href.starts_with("/dav.php") {
             // Event href is already a full path, combine with base server URL (without /dav.php)
-            let base_url = self.config.server_url.trim_end_matches('/').trim_end_matches("/dav.php");
+            let base_url = self
+                .config
+                .server_url
+                .trim_end_matches('/')
+                .trim_end_matches("/dav.php");
             format!("{}{}", base_url, event_href)
         } else {
             // Event href is just a filename, combine with calendar path
@@ -829,26 +961,35 @@ impl CalDAVClient {
             } else {
                 calendar_path
             };
-            format!("{}/dav.php{}/{}", self.config.server_url.trim_end_matches('/'), clean_path, event_href)
+            format!(
+                "{}/dav.php{}/{}",
+                self.config.server_url.trim_end_matches('/'),
+                clean_path,
+                event_href
+            )
         };
-        
+
         println!("📝 Updating event at: {}", full_url);
-        
+
         // Generate iCalendar data for the event
         let ical_data = self.generate_ical_event(event)?;
-        
+
         println!("📝 Updated iCal data: {}", ical_data);
         println!("📝 Event has {} exception dates", event.exdate.len());
-        
+
         println!("📡 Acquiring CalDAV HTTP lock for PUT request...");
         let _lock = CALDAV_HTTP_MUTEX.lock().await;
         println!("📡 Lock acquired, sending PUT request to CalDAV server...");
         println!("🔗 PUT URL: {}", full_url);
         println!("🔍 Request headers: Authorization: Basic [HIDDEN], Content-Type: text/calendar; charset=utf-8");
-        
-        let response = self.http_client
+
+        let response = self
+            .http_client
             .put(&full_url)
-            .header("Authorization", format!("Basic {}", self.config.get_basic_auth()))
+            .header(
+                "Authorization",
+                format!("Basic {}", self.config.get_basic_auth()),
+            )
             .header("Content-Type", "text/calendar; charset=utf-8")
             .header("User-Agent", "calendar-app/0.1.0")
             .timeout(std::time::Duration::from_secs(30))
@@ -861,8 +1002,11 @@ impl CalDAVClient {
             })?;
 
         println!("Event update response status: {}", response.status());
-        
-        if response.status().is_success() || response.status().as_u16() == 201 || response.status().as_u16() == 204 {
+
+        if response.status().is_success()
+            || response.status().as_u16() == 201
+            || response.status().as_u16() == 204
+        {
             println!("✅ Event updated successfully");
             Ok(())
         } else {
@@ -876,30 +1020,30 @@ impl CalDAVClient {
     /// Generate iCalendar data for a CalendarEvent
     fn generate_ical_event(&self, event: &CalendarEvent) -> Result<String, CalDAVError> {
         let now = chrono::Utc::now();
-        
+
         // Format datetime for iCal (YYYYMMDDTHHMMSSZ format)
-        let format_datetime = |dt: &DateTime<Utc>| -> String {
-            dt.format("%Y%m%dT%H%M%SZ").to_string()
-        };
-        
-        let format_date = |dt: &DateTime<Utc>| -> String {
-            dt.format("%Y%m%d").to_string()
-        };
-        
+        let format_datetime =
+            |dt: &DateTime<Utc>| -> String { dt.format("%Y%m%dT%H%M%SZ").to_string() };
+
+        let format_date = |dt: &DateTime<Utc>| -> String { dt.format("%Y%m%d").to_string() };
+
         // Start building the iCal event
         let mut ical = String::new();
         ical.push_str("BEGIN:VCALENDAR\r\n");
         ical.push_str("VERSION:2.0\r\n");
         ical.push_str("PRODID:-//calendar-app//calendar-app//EN\r\n");
         ical.push_str("BEGIN:VEVENT\r\n");
-        
+
         // Required fields
         ical.push_str(&format!("UID:{}\r\n", event.uid));
         ical.push_str(&format!("DTSTAMP:{}\r\n", format_datetime(&now)));
-        
+
         // Start and end times
         if event.all_day {
-            ical.push_str(&format!("DTSTART;VALUE=DATE:{}\r\n", format_date(&event.dtstart)));
+            ical.push_str(&format!(
+                "DTSTART;VALUE=DATE:{}\r\n",
+                format_date(&event.dtstart)
+            ));
             if let Some(end) = &event.dtend {
                 ical.push_str(&format!("DTEND;VALUE=DATE:{}\r\n", format_date(end)));
             }
@@ -909,30 +1053,33 @@ impl CalDAVClient {
                 ical.push_str(&format!("DTEND:{}\r\n", format_datetime(end)));
             }
         }
-        
+
         // Optional fields
         if let Some(summary) = &event.summary {
             ical.push_str(&format!("SUMMARY:{}\r\n", self.escape_ical_text(summary)));
         }
-        
+
         if let Some(description) = &event.description {
-            ical.push_str(&format!("DESCRIPTION:{}\r\n", self.escape_ical_text(description)));
+            ical.push_str(&format!(
+                "DESCRIPTION:{}\r\n",
+                self.escape_ical_text(description)
+            ));
         }
-        
+
         if let Some(location) = &event.location {
             ical.push_str(&format!("LOCATION:{}\r\n", self.escape_ical_text(location)));
         }
-        
+
         // Status
         if let Some(status) = &event.status {
             let status_str = match status {
                 EventStatus::Tentative => "TENTATIVE",
-                EventStatus::Confirmed => "CONFIRMED", 
+                EventStatus::Confirmed => "CONFIRMED",
                 EventStatus::Cancelled => "CANCELLED",
             };
             ical.push_str(&format!("STATUS:{}\r\n", status_str));
         }
-        
+
         // Classification
         if let Some(class) = &event.class {
             let class_str = match class {
@@ -942,37 +1089,40 @@ impl CalDAVClient {
             };
             ical.push_str(&format!("CLASS:{}\r\n", class_str));
         }
-        
+
         // Priority
         if let Some(priority) = event.priority {
             ical.push_str(&format!("PRIORITY:{}\r\n", priority));
         }
-        
+
         // Categories
         if !event.categories.is_empty() {
             let categories = event.categories.join(",");
-            ical.push_str(&format!("CATEGORIES:{}\r\n", self.escape_ical_text(&categories)));
+            ical.push_str(&format!(
+                "CATEGORIES:{}\r\n",
+                self.escape_ical_text(&categories)
+            ));
         }
-        
+
         // Creation and modification times
         if let Some(created) = &event.created {
             ical.push_str(&format!("CREATED:{}\r\n", format_datetime(created)));
         }
-        
+
         ical.push_str(&format!("LAST-MODIFIED:{}\r\n", format_datetime(&now)));
-        
+
         // Add alarms/reminders
         for alarm in &event.alarms {
             ical.push_str("BEGIN:VALARM\r\n");
-            
+
             let action = match alarm.action {
                 calendar_models::AlarmAction::Display => "DISPLAY",
-                calendar_models::AlarmAction::Email => "EMAIL", 
+                calendar_models::AlarmAction::Email => "EMAIL",
                 calendar_models::AlarmAction::Audio => "AUDIO",
                 calendar_models::AlarmAction::Procedure => "PROCEDURE",
             };
             ical.push_str(&format!("ACTION:{}\r\n", action));
-            
+
             // Handle trigger
             match &alarm.trigger {
                 calendar_models::AlarmTrigger::Duration(duration) => {
@@ -987,36 +1137,45 @@ impl CalDAVClient {
                     ical.push_str(&format!("TRIGGER:{}\r\n", format_datetime(dt)));
                 }
             }
-            
+
             if let Some(description) = &alarm.description {
-                ical.push_str(&format!("DESCRIPTION:{}\r\n", self.escape_ical_text(description)));
+                ical.push_str(&format!(
+                    "DESCRIPTION:{}\r\n",
+                    self.escape_ical_text(description)
+                ));
             } else if let Some(summary) = &event.summary {
-                ical.push_str(&format!("DESCRIPTION:{}\r\n", self.escape_ical_text(summary)));
+                ical.push_str(&format!(
+                    "DESCRIPTION:{}\r\n",
+                    self.escape_ical_text(summary)
+                ));
             }
-            
+
             ical.push_str("END:VALARM\r\n");
         }
-        
+
         // Recurrence rule
         if let Some(rrule) = &event.rrule {
             ical.push_str(&format!("RRULE:{}\r\n", rrule));
         }
-        
+
         // Exception dates (EXDATE)
         for exception_date in &event.exdate {
             if event.all_day {
-                ical.push_str(&format!("EXDATE;VALUE=DATE:{}\r\n", format_date(exception_date)));
+                ical.push_str(&format!(
+                    "EXDATE;VALUE=DATE:{}\r\n",
+                    format_date(exception_date)
+                ));
             } else {
                 ical.push_str(&format!("EXDATE:{}\r\n", format_datetime(exception_date)));
             }
         }
-        
+
         ical.push_str("END:VEVENT\r\n");
         ical.push_str("END:VCALENDAR\r\n");
-        
+
         Ok(ical)
     }
-    
+
     /// Escape text for iCalendar format (RFC 5545)
     fn escape_ical_text(&self, text: &str) -> String {
         text.replace('\\', "\\\\")
@@ -1027,13 +1186,21 @@ impl CalDAVClient {
     }
 
     /// Delete an event from a CalDAV calendar
-    pub async fn delete_event(&self, calendar_path: &str, event_href: &str) -> Result<(), CalDAVError> {
+    pub async fn delete_event(
+        &self,
+        calendar_path: &str,
+        event_href: &str,
+    ) -> Result<(), CalDAVError> {
         // Construct the full URL for the event
         let full_url = if event_href.starts_with("http") {
             event_href.to_string()
         } else if event_href.starts_with("/dav.php") {
             // Event href is already a full path, combine with base server URL (without /dav.php)
-            let base_url = self.config.server_url.trim_end_matches('/').trim_end_matches("/dav.php");
+            let base_url = self
+                .config
+                .server_url
+                .trim_end_matches('/')
+                .trim_end_matches("/dav.php");
             format!("{}{}", base_url, event_href)
         } else {
             // Event href is just a filename, combine with calendar path
@@ -1042,24 +1209,33 @@ impl CalDAVClient {
             } else {
                 calendar_path
             };
-            format!("{}/dav.php{}/{}", self.config.server_url.trim_end_matches('/'), clean_path, event_href)
+            format!(
+                "{}/dav.php{}/{}",
+                self.config.server_url.trim_end_matches('/'),
+                clean_path,
+                event_href
+            )
         };
-        
+
         println!("Deleting event at: {}", full_url);
-        
+
         println!("📡 Acquiring CalDAV HTTP lock for DELETE request...");
         let _lock = CALDAV_HTTP_MUTEX.lock().await;
         println!("📡 Lock acquired, sending DELETE request to CalDAV server...");
-        
-        let response = self.http_client
+
+        let response = self
+            .http_client
             .delete(&full_url)
-            .header("Authorization", format!("Basic {}", self.config.get_basic_auth()))
+            .header(
+                "Authorization",
+                format!("Basic {}", self.config.get_basic_auth()),
+            )
             .send()
             .await
             .map_err(|e| CalDAVError::ParseError(e.to_string()))?;
 
         println!("Event deletion response status: {}", response.status());
-        
+
         if response.status().is_success() || response.status().as_u16() == 204 {
             println!("✅ Event deleted successfully at {}", event_href);
             Ok(())
@@ -1085,10 +1261,10 @@ struct CalendarDataSection {
 pub enum CalDAVError {
     #[error("HTTP request failed: {0}")]
     RequestError(#[from] reqwest::Error),
-    
+
     #[error("CalDAV server returned error: {0}")]
     ServerError(u16),
-    
+
     #[error("Failed to parse calendar data: {0}")]
     ParseError(String),
 }
@@ -1099,36 +1275,39 @@ mod tests {
     use crate::config::CalDAVConfig;
 
     /// Integration test that fetches real calendar events from the Baikal server
-    /// 
+    ///
     /// This test requires a valid .env file and a calendar with some events
     #[tokio::test]
     async fn test_fetch_calendar_events() {
-        let config = CalDAVConfig::from_env()
-            .expect("Failed to load CalDAV config from environment");
-        
+        let config = CalDAVConfig::new(
+            "https://example.com".to_string(),
+            "test_user".to_string(),
+            "test_password".to_string(),
+        );
+
         let client = CalDAVClient::new(config);
-        
+
         // First discover available calendars using PROPFIND
         println!("Discovering calendars...");
         let discovery_result = client.discover_calendars().await;
-        
+
         match discovery_result {
             Ok(calendar_paths) => {
                 println!("Found {} calendar collection(s)", calendar_paths.len());
-                
+
                 if calendar_paths.is_empty() {
                     println!("No calendars found - this might be normal for a new server");
                     return;
                 }
-                
+
                 // Try the first available calendar
                 let calendar_path = &calendar_paths[0];
                 println!("Trying to fetch events from: {}", calendar_path);
-                
+
                 match client.fetch_events(calendar_path).await {
                     Ok(events) => {
                         println!("Successfully fetched {} calendar events", events.len());
-                        
+
                         for (i, event) in events.iter().take(3).enumerate() {
                             println!("\n--- Event {} ---", i + 1);
                             println!("UID: {}", event.uid);
@@ -1142,14 +1321,17 @@ mod tests {
                             println!("ETag: {:?}", event.etag);
                             println!("HREF: {:?}", event.href);
                         }
-                        
+
                         // Validate that events have required fields
                         for event in &events {
                             assert!(!event.uid.is_empty(), "Event UID should not be empty");
                             // All events should have a start time
-                            assert!(event.dtstart > DateTime::from_timestamp(0, 0).unwrap(), "Event should have valid start time");
+                            assert!(
+                                event.dtstart > DateTime::from_timestamp(0, 0).unwrap(),
+                                "Event should have valid start time"
+                            );
                         }
-                        
+
                         println!("\n✓ Calendar event fetching test passed!");
                     }
                     Err(e) => {
@@ -1192,15 +1374,15 @@ END:VCALENDAR"#;
             username: "test".to_string(),
             password: "test".to_string(),
             calendar_path: None,
-            tasks_path: None,
         };
-        
+
         let client = CalDAVClient::new(config);
-        let events = client.parse_ical_data(sample_ical)
+        let events = client
+            .parse_ical_data(sample_ical)
             .expect("Should be able to parse sample iCal data");
 
         assert_eq!(events.len(), 1);
-        
+
         let event = &events[0];
         assert_eq!(event.uid, "test-event-123@example.com");
         assert_eq!(event.summary, Some("Test Event".to_string()));
@@ -1211,7 +1393,7 @@ END:VCALENDAR"#;
         assert_eq!(event.priority, Some(5));
         assert_eq!(event.categories, vec!["work", "important"]);
         assert!(!event.all_day);
-        
+
         println!("✓ iCal parsing test passed!");
     }
 
@@ -1223,26 +1405,28 @@ END:VCALENDAR"#;
             username: "test".to_string(),
             password: "test".to_string(),
             calendar_path: None,
-            tasks_path: None,
         };
-        
+
         let client = CalDAVClient::new(config);
-        
+
         // Test UTC format
-        let dt1 = client.parse_datetime("20231225T120000Z", None)
+        let dt1 = client
+            .parse_datetime("20231225T120000Z", None)
             .expect("Should parse UTC datetime");
         println!("Parsed UTC datetime: {}", dt1);
-        
+
         // Test date-only format (should be treated as all-day)
-        let dt2 = client.parse_datetime("20231225", None)
+        let dt2 = client
+            .parse_datetime("20231225", None)
             .expect("Should parse date-only");
         println!("Parsed date-only: {}", dt2);
-        
+
         // Test local format
-        let dt3 = client.parse_datetime("20231225T120000", None)
+        let dt3 = client
+            .parse_datetime("20231225T120000", None)
             .expect("Should parse local datetime");
         println!("Parsed local datetime: {}", dt3);
-        
+
         println!("✓ Datetime parsing test passed!");
     }
 
@@ -1252,12 +1436,11 @@ END:VCALENDAR"#;
         // Test status parsing - these don't have defaults, so let's test creation
         let status = EventStatus::Confirmed;
         assert_eq!(status, EventStatus::Confirmed);
-        
+
         // Test class parsing
         let class = EventClass::Public;
         assert_eq!(class, EventClass::Public);
-        
+
         println!("✓ Event enum tests passed!");
     }
-
 }
diff --git a/backend/src/config.rs b/backend/src/config.rs
index 2154c15..a383780 100644
--- a/backend/src/config.rs
+++ b/backend/src/config.rs
@@ -1,30 +1,30 @@
+use base64::prelude::*;
 use serde::{Deserialize, Serialize};
 use std::env;
-use base64::prelude::*;
 
 /// Configuration for CalDAV server connection and authentication.
-/// 
+///
 /// This struct holds all the necessary information to connect to a CalDAV server,
 /// including server URL, credentials, and optional collection paths.
-/// 
+///
 /// # Security Note
-/// 
+///
 /// The password field contains sensitive information and should be handled carefully.
 /// This struct implements `Debug` but in production, consider implementing a custom
 /// `Debug` that masks the password field.
-/// 
+///
 /// # Example
-/// 
+///
 /// ```rust
 /// # use calendar_backend::config::CalDAVConfig;
 /// let config = CalDAVConfig {
 ///     server_url: "https://caldav.example.com".to_string(),
-///     username: "user@example.com".to_string(), 
+///     username: "user@example.com".to_string(),
 ///     password: "password".to_string(),
 ///     calendar_path: None,
 ///     tasks_path: None,
 /// };
-/// 
+///
 /// // Use the configuration for HTTP requests
 /// let auth_header = format!("Basic {}", config.get_basic_auth());
 /// ```
@@ -32,17 +32,17 @@ use base64::prelude::*;
 pub struct CalDAVConfig {
     /// The base URL of the CalDAV server (e.g., "https://caldav.example.com/dav/")
     pub server_url: String,
-    
+
     /// Username for authentication with the CalDAV server
     pub username: String,
-    
+
     /// Password for authentication with the CalDAV server
-    /// 
+    ///
     /// **Security Note**: This contains sensitive information
     pub password: String,
-    
+
     /// Optional path to the calendar collection on the server
-    /// 
+    ///
     /// If not provided, the client will discover available calendars
     /// through CalDAV PROPFIND requests
     pub calendar_path: Option<String>,
@@ -50,20 +50,20 @@ pub struct CalDAVConfig {
 
 impl CalDAVConfig {
     /// Creates a new CalDAVConfig with the given credentials.
-    /// 
+    ///
     /// # Arguments
-    /// 
+    ///
     /// * `server_url` - The base URL of the CalDAV server
     /// * `username` - Username for authentication
     /// * `password` - Password for authentication
-    /// 
+    ///
     /// # Example
-    /// 
+    ///
     /// ```rust
     /// # use calendar_backend::config::CalDAVConfig;
     /// let config = CalDAVConfig::new(
     ///     "https://caldav.example.com".to_string(),
-    ///     "user@example.com".to_string(), 
+    ///     "user@example.com".to_string(),
     ///     "password".to_string()
     /// );
     /// ```
@@ -77,21 +77,21 @@ impl CalDAVConfig {
     }
 
     /// Generates a Base64-encoded string for HTTP Basic Authentication.
-    /// 
+    ///
     /// This method combines the username and password in the format
     /// `username:password` and encodes it using Base64, which is the
     /// standard format for the `Authorization: Basic` HTTP header.
-    /// 
+    ///
     /// # Returns
-    /// 
+    ///
     /// A Base64-encoded string that can be used directly in the
     /// `Authorization` header: `Authorization: Basic <returned_value>`
-    /// 
+    ///
     /// # Example
-    /// 
+    ///
     /// ```rust
     /// # use calendar_backend::config::CalDAVConfig;
-    /// 
+    ///
     /// let config = CalDAVConfig {
     ///     server_url: "https://example.com".to_string(),
     ///     username: "user".to_string(),
@@ -99,7 +99,7 @@ impl CalDAVConfig {
     ///     calendar_path: None,
     ///     tasks_path: None,
     /// };
-    /// 
+    ///
     /// let auth_value = config.get_basic_auth();
     /// let auth_header = format!("Basic {}", auth_value);
     /// ```
@@ -113,15 +113,15 @@ impl CalDAVConfig {
 #[derive(Debug, thiserror::Error)]
 pub enum ConfigError {
     /// A required environment variable is missing or cannot be read.
-    /// 
+    ///
     /// This error occurs when calling `CalDAVConfig::from_env()` and one of the
     /// required environment variables (`CALDAV_SERVER_URL`, `CALDAV_USERNAME`,
     /// or `CALDAV_PASSWORD`) is not set.
     #[error("Missing environment variable: {0}")]
     MissingVar(String),
-    
+
     /// The configuration contains invalid or malformed values.
-    /// 
+    ///
     /// This could include malformed URLs, invalid authentication credentials,
     /// or other configuration issues that prevent proper CalDAV operation.
     #[error("Invalid configuration: {0}")]
@@ -139,7 +139,6 @@ mod tests {
             username: "testuser".to_string(),
             password: "testpass".to_string(),
             calendar_path: None,
-            tasks_path: None,
         };
 
         let auth = config.get_basic_auth();
@@ -148,12 +147,12 @@ mod tests {
     }
 
     /// Integration test that authenticates with the actual Baikal CalDAV server
-    /// 
+    ///
     /// This test requires a valid .env file with:
     /// - CALDAV_SERVER_URL
     /// - CALDAV_USERNAME  
     /// - CALDAV_PASSWORD
-    /// 
+    ///
     /// Run with: `cargo test test_baikal_auth`
     #[tokio::test]
     async fn test_baikal_auth() {
@@ -161,7 +160,7 @@ mod tests {
         let config = CalDAVConfig::new(
             "https://example.com".to_string(),
             "test_user".to_string(),
-            "test_password".to_string()
+            "test_password".to_string(),
         );
 
         println!("Testing authentication to: {}", config.server_url);
@@ -172,7 +171,10 @@ mod tests {
         // Make a simple OPTIONS request to test authentication
         let response = client
             .request(reqwest::Method::OPTIONS, &config.server_url)
-            .header("Authorization", format!("Basic {}", config.get_basic_auth()))
+            .header(
+                "Authorization",
+                format!("Basic {}", config.get_basic_auth()),
+            )
             .header("User-Agent", "calendar-app/0.1.0")
             .send()
             .await
@@ -190,9 +192,9 @@ mod tests {
 
         // For Baikal/CalDAV servers, we should see DAV headers
         assert!(
-            response.headers().contains_key("dav") || 
-            response.headers().contains_key("DAV") ||
-            response.status().is_success(),
+            response.headers().contains_key("dav")
+                || response.headers().contains_key("DAV")
+                || response.status().is_success(),
             "Server doesn't appear to be a CalDAV server - missing DAV headers"
         );
 
@@ -200,17 +202,17 @@ mod tests {
     }
 
     /// Test making a PROPFIND request to discover calendars
-    /// 
+    ///
     /// This test requires a valid .env file and makes an actual CalDAV PROPFIND request
-    /// 
+    ///
     /// Run with: `cargo test test_propfind_calendars`
     #[tokio::test]
     async fn test_propfind_calendars() {
-        // Use test config - update these values to test with real server  
+        // Use test config - update these values to test with real server
         let config = CalDAVConfig::new(
             "https://example.com".to_string(),
             "test_user".to_string(),
-            "test_password".to_string()
+            "test_password".to_string(),
         );
 
         let client = reqwest::Client::new();
@@ -227,8 +229,14 @@ mod tests {
 </d:propfind>"#;
 
         let response = client
-            .request(reqwest::Method::from_bytes(b"PROPFIND").unwrap(), &config.server_url)
-            .header("Authorization", format!("Basic {}", config.get_basic_auth()))
+            .request(
+                reqwest::Method::from_bytes(b"PROPFIND").unwrap(),
+                &config.server_url,
+            )
+            .header(
+                "Authorization",
+                format!("Basic {}", config.get_basic_auth()),
+            )
             .header("Content-Type", "application/xml")
             .header("Depth", "1")
             .header("User-Agent", "calendar-app/0.1.0")
@@ -239,7 +247,7 @@ mod tests {
 
         let status = response.status();
         println!("PROPFIND Response status: {}", status);
-        
+
         let body = response.text().await.expect("Failed to read response body");
         println!("PROPFIND Response body: {}", body);
 
@@ -251,8 +259,11 @@ mod tests {
         );
 
         // The response should contain XML with calendar information
-        assert!(body.contains("calendar"), "Response should contain calendar information");
+        assert!(
+            body.contains("calendar"),
+            "Response should contain calendar information"
+        );
 
         println!("✓ PROPFIND calendars test passed!");
     }
-}
\ No newline at end of file
+}
diff --git a/backend/src/handlers.rs b/backend/src/handlers.rs
index a45f29a..a143e74 100644
--- a/backend/src/handlers.rs
+++ b/backend/src/handlers.rs
@@ -4,7 +4,7 @@ mod calendar;
 mod events;
 mod series;
 
-pub use auth::{login, verify_token, get_user_info};
+pub use auth::{get_user_info, login, verify_token};
 pub use calendar::{create_calendar, delete_calendar};
-pub use events::{get_calendar_events, refresh_event, create_event, update_event, delete_event};
-pub use series::{create_event_series, update_event_series, delete_event_series};
\ No newline at end of file
+pub use events::{create_event, delete_event, get_calendar_events, refresh_event, update_event};
+pub use series::{create_event_series, delete_event_series, update_event_series};
diff --git a/backend/src/handlers/auth.rs b/backend/src/handlers/auth.rs
index 425ba30..730bb22 100644
--- a/backend/src/handlers/auth.rs
+++ b/backend/src/handlers/auth.rs
@@ -1,33 +1,38 @@
-use axum::{
-    extract::State,
-    http::HeaderMap,
-    response::Json,
-};
+use axum::{extract::State, http::HeaderMap, response::Json};
 use std::sync::Arc;
 
-use crate::{AppState, models::{CalDAVLoginRequest, AuthResponse, ApiError, UserInfo, CalendarInfo}};
 use crate::calendar::CalDAVClient;
 use crate::config::CalDAVConfig;
+use crate::{
+    models::{ApiError, AuthResponse, CalDAVLoginRequest, CalendarInfo, UserInfo},
+    AppState,
+};
 
 pub fn extract_bearer_token(headers: &HeaderMap) -> Result<String, ApiError> {
-    let auth_header = headers.get("authorization")
+    let auth_header = headers
+        .get("authorization")
         .ok_or_else(|| ApiError::Unauthorized("Missing Authorization header".to_string()))?;
-    
-    let auth_str = auth_header.to_str()
+
+    let auth_str = auth_header
+        .to_str()
         .map_err(|_| ApiError::BadRequest("Invalid Authorization header".to_string()))?;
-    
+
     if let Some(token) = auth_str.strip_prefix("Bearer ") {
         Ok(token.to_string())
     } else {
-        Err(ApiError::BadRequest("Authorization header must be Bearer token".to_string()))
+        Err(ApiError::BadRequest(
+            "Authorization header must be Bearer token".to_string(),
+        ))
     }
 }
 
 pub fn extract_password_header(headers: &HeaderMap) -> Result<String, ApiError> {
-    let password_header = headers.get("x-caldav-password")
+    let password_header = headers
+        .get("x-caldav-password")
         .ok_or_else(|| ApiError::BadRequest("Missing X-CalDAV-Password header".to_string()))?;
-    
-    password_header.to_str()
+
+    password_header
+        .to_str()
         .map(|s| s.to_string())
         .map_err(|_| ApiError::BadRequest("Invalid X-CalDAV-Password header".to_string()))
 }
@@ -40,32 +45,37 @@ pub async fn login(
     println!("  Server URL: {}", request.server_url);
     println!("  Username: {}", request.username);
     println!("  Password length: {}", request.password.len());
-    
+
     // Basic validation
     if request.username.is_empty() || request.password.is_empty() || request.server_url.is_empty() {
-        return Err(ApiError::BadRequest("Username, password, and server URL are required".to_string()));
+        return Err(ApiError::BadRequest(
+            "Username, password, and server URL are required".to_string(),
+        ));
     }
-    
+
     println!("✅ Input validation passed");
-    
+
     // Create a token using the auth service
     println!("📝 Created CalDAV config");
-    
+
     // First verify the credentials are valid by attempting to discover calendars
     let config = CalDAVConfig::new(
         request.server_url.clone(),
         request.username.clone(),
-        request.password.clone()
+        request.password.clone(),
     );
     let client = CalDAVClient::new(config);
-    client.discover_calendars()
+    client
+        .discover_calendars()
         .await
         .map_err(|e| ApiError::Unauthorized(format!("Authentication failed: {}", e)))?;
-    
-    let token = state.auth_service.generate_token(&request.username, &request.server_url)?;
-    
+
+    let token = state
+        .auth_service
+        .generate_token(&request.username, &request.server_url)?;
+
     println!("🔗 Created CalDAV client, attempting to discover calendars...");
-    
+
     Ok(Json(AuthResponse {
         token,
         username: request.username,
@@ -79,7 +89,7 @@ pub async fn verify_token(
 ) -> Result<Json<serde_json::Value>, ApiError> {
     let token = extract_bearer_token(&headers)?;
     let is_valid = state.auth_service.verify_token(&token).is_ok();
-    
+
     Ok(Json(serde_json::json!({ "valid": is_valid })))
 }
 
@@ -89,26 +99,33 @@ pub async fn get_user_info(
 ) -> Result<Json<UserInfo>, ApiError> {
     let token = extract_bearer_token(&headers)?;
     let password = extract_password_header(&headers)?;
-    
+
     // Create CalDAV config from token and password
-    let config = state.auth_service.caldav_config_from_token(&token, &password)?;
+    let config = state
+        .auth_service
+        .caldav_config_from_token(&token, &password)?;
     let client = CalDAVClient::new(config.clone());
-    
+
     // Discover calendars
-    let calendar_paths = client.discover_calendars()
+    let calendar_paths = client
+        .discover_calendars()
         .await
         .map_err(|e| ApiError::Internal(format!("Failed to discover calendars: {}", e)))?;
-        
-    println!("✅ Authentication successful! Found {} calendars", calendar_paths.len());
-    
-    let calendars: Vec<CalendarInfo> = calendar_paths.iter().map(|path| {
-        CalendarInfo {
+
+    println!(
+        "✅ Authentication successful! Found {} calendars",
+        calendar_paths.len()
+    );
+
+    let calendars: Vec<CalendarInfo> = calendar_paths
+        .iter()
+        .map(|path| CalendarInfo {
             path: path.clone(),
             display_name: extract_calendar_name(path),
             color: generate_calendar_color(path),
-        }
-    }).collect();
-    
+        })
+        .collect();
+
     Ok(Json(UserInfo {
         username: config.username,
         server_url: config.server_url,
@@ -123,15 +140,14 @@ fn generate_calendar_color(path: &str) -> String {
     for byte in path.bytes() {
         hash = hash.wrapping_mul(31).wrapping_add(byte as u32);
     }
-    
+
     // Define a set of pleasant colors
     let colors = [
-        "#3B82F6", "#10B981", "#F59E0B", "#EF4444", "#8B5CF6",
-        "#06B6D4", "#84CC16", "#F97316", "#EC4899", "#6366F1",
-        "#14B8A6", "#F3B806", "#8B5A2B", "#6B7280", "#DC2626",
-        "#7C3AED", "#059669", "#D97706", "#BE185D", "#4F46E5"
+        "#3B82F6", "#10B981", "#F59E0B", "#EF4444", "#8B5CF6", "#06B6D4", "#84CC16", "#F97316",
+        "#EC4899", "#6366F1", "#14B8A6", "#F3B806", "#8B5A2B", "#6B7280", "#DC2626", "#7C3AED",
+        "#059669", "#D97706", "#BE185D", "#4F46E5",
     ];
-    
+
     colors[(hash as usize) % colors.len()].to_string()
 }
 
@@ -154,4 +170,4 @@ fn extract_calendar_name(path: &str) -> String {
         })
         .collect::<Vec<String>>()
         .join(" ")
-}
\ No newline at end of file
+}
diff --git a/backend/src/handlers/calendar.rs b/backend/src/handlers/calendar.rs
index d7f1972..f4a34f6 100644
--- a/backend/src/handlers/calendar.rs
+++ b/backend/src/handlers/calendar.rs
@@ -1,12 +1,14 @@
-use axum::{
-    extract::State,
-    http::HeaderMap,
-    response::Json,
-};
+use axum::{extract::State, http::HeaderMap, response::Json};
 use std::sync::Arc;
 
-use crate::{AppState, models::{ApiError, CreateCalendarRequest, CreateCalendarResponse, DeleteCalendarRequest, DeleteCalendarResponse}};
 use crate::calendar::CalDAVClient;
+use crate::{
+    models::{
+        ApiError, CreateCalendarRequest, CreateCalendarResponse, DeleteCalendarRequest,
+        DeleteCalendarResponse,
+    },
+    AppState,
+};
 
 use super::auth::{extract_bearer_token, extract_password_header};
 
@@ -20,22 +22,36 @@ pub async fn create_calendar(
 
     // Validate request
     if request.name.trim().is_empty() {
-        return Err(ApiError::BadRequest("Calendar name is required".to_string()));
+        return Err(ApiError::BadRequest(
+            "Calendar name is required".to_string(),
+        ));
     }
 
     // Create CalDAV config from token and password
-    let config = state.auth_service.caldav_config_from_token(&token, &password)?;
+    let config = state
+        .auth_service
+        .caldav_config_from_token(&token, &password)?;
     let client = CalDAVClient::new(config);
 
     // Create calendar on CalDAV server
-    match client.create_calendar(&request.name, request.description.as_deref(), request.color.as_deref()).await {
+    match client
+        .create_calendar(
+            &request.name,
+            request.description.as_deref(),
+            request.color.as_deref(),
+        )
+        .await
+    {
         Ok(_) => Ok(Json(CreateCalendarResponse {
             success: true,
             message: "Calendar created successfully".to_string(),
         })),
         Err(e) => {
             eprintln!("Failed to create calendar: {}", e);
-            Err(ApiError::Internal(format!("Failed to create calendar: {}", e)))
+            Err(ApiError::Internal(format!(
+                "Failed to create calendar: {}",
+                e
+            )))
         }
     }
 }
@@ -50,11 +66,15 @@ pub async fn delete_calendar(
 
     // Validate request
     if request.path.trim().is_empty() {
-        return Err(ApiError::BadRequest("Calendar path is required".to_string()));
+        return Err(ApiError::BadRequest(
+            "Calendar path is required".to_string(),
+        ));
     }
 
     // Create CalDAV config from token and password
-    let config = state.auth_service.caldav_config_from_token(&token, &password)?;
+    let config = state
+        .auth_service
+        .caldav_config_from_token(&token, &password)?;
     let client = CalDAVClient::new(config);
 
     // Delete calendar on CalDAV server
@@ -65,7 +85,10 @@ pub async fn delete_calendar(
         })),
         Err(e) => {
             eprintln!("Failed to delete calendar: {}", e);
-            Err(ApiError::Internal(format!("Failed to delete calendar: {}", e)))
+            Err(ApiError::Internal(format!(
+                "Failed to delete calendar: {}",
+                e
+            )))
         }
     }
-}
\ No newline at end of file
+}
diff --git a/backend/src/handlers/events.rs b/backend/src/handlers/events.rs
index b9531e8..500f99f 100644
--- a/backend/src/handlers/events.rs
+++ b/backend/src/handlers/events.rs
@@ -1,15 +1,23 @@
 use axum::{
-    extract::{State, Query, Path},
+    extract::{Path, Query, State},
     http::HeaderMap,
     response::Json,
 };
+use chrono::Datelike;
 use serde::Deserialize;
 use std::sync::Arc;
-use chrono::Datelike;
 
-use calendar_models::{VEvent, EventStatus, EventClass, CalendarUser, Attendee, VAlarm, AlarmAction, AlarmTrigger};
-use crate::{AppState, models::{ApiError, DeleteEventRequest, DeleteEventResponse, CreateEventRequest, CreateEventResponse, UpdateEventRequest, UpdateEventResponse}};
 use crate::calendar::{CalDAVClient, CalendarEvent};
+use crate::{
+    models::{
+        ApiError, CreateEventRequest, CreateEventResponse, DeleteEventRequest, DeleteEventResponse,
+        UpdateEventRequest, UpdateEventResponse,
+    },
+    AppState,
+};
+use calendar_models::{
+    AlarmAction, AlarmTrigger, Attendee, CalendarUser, EventClass, EventStatus, VAlarm, VEvent,
+};
 
 use super::auth::{extract_bearer_token, extract_password_header};
 
@@ -28,20 +36,23 @@ pub async fn get_calendar_events(
     let token = extract_bearer_token(&headers)?;
     let password = extract_password_header(&headers)?;
     println!("🔑 API call with password length: {}", password.len());
-    
+
     // Create CalDAV config from token and password
-    let config = state.auth_service.caldav_config_from_token(&token, &password)?;
+    let config = state
+        .auth_service
+        .caldav_config_from_token(&token, &password)?;
     let client = CalDAVClient::new(config);
-    
+
     // Discover calendars if needed
-    let calendar_paths = client.discover_calendars()
+    let calendar_paths = client
+        .discover_calendars()
         .await
         .map_err(|e| ApiError::Internal(format!("Failed to discover calendars: {}", e)))?;
-    
+
     if calendar_paths.is_empty() {
         return Ok(Json(vec![])); // No calendars found
     }
-    
+
     // Fetch events from all calendars
     let mut all_events = Vec::new();
     for calendar_path in &calendar_paths {
@@ -54,12 +65,15 @@ pub async fn get_calendar_events(
                 all_events.extend(events);
             }
             Err(e) => {
-                eprintln!("Failed to fetch events from calendar {}: {}", calendar_path, e);
+                eprintln!(
+                    "Failed to fetch events from calendar {}: {}",
+                    calendar_path, e
+                );
                 // Continue with other calendars instead of failing completely
             }
         }
     }
-    
+
     // If year and month are specified, filter events
     if let (Some(year), Some(month)) = (params.year, params.month) {
         all_events.retain(|event| {
@@ -68,7 +82,7 @@ pub async fn get_calendar_events(
             event_year == year && event_month == month
         });
     }
-    
+
     println!("📅 Returning {} events", all_events.len());
     Ok(Json(all_events))
 }
@@ -80,16 +94,19 @@ pub async fn refresh_event(
 ) -> Result<Json<Option<CalendarEvent>>, ApiError> {
     let token = extract_bearer_token(&headers)?;
     let password = extract_password_header(&headers)?;
-    
+
     // Create CalDAV config from token and password
-    let config = state.auth_service.caldav_config_from_token(&token, &password)?;
+    let config = state
+        .auth_service
+        .caldav_config_from_token(&token, &password)?;
     let client = CalDAVClient::new(config);
-    
+
     // Discover calendars
-    let calendar_paths = client.discover_calendars()
+    let calendar_paths = client
+        .discover_calendars()
         .await
         .map_err(|e| ApiError::Internal(format!("Failed to discover calendars: {}", e)))?;
-    
+
     // Search for the event by UID across all calendars
     for calendar_path in &calendar_paths {
         if let Ok(Some(mut event)) = client.fetch_event_by_uid(calendar_path, &uid).await {
@@ -97,18 +114,25 @@ pub async fn refresh_event(
             return Ok(Json(Some(event)));
         }
     }
-    
+
     Ok(Json(None))
 }
 
-async fn fetch_event_by_href(client: &CalDAVClient, calendar_path: &str, event_href: &str) -> Result<Option<CalendarEvent>, crate::calendar::CalDAVError> {
+async fn fetch_event_by_href(
+    client: &CalDAVClient,
+    calendar_path: &str,
+    event_href: &str,
+) -> Result<Option<CalendarEvent>, crate::calendar::CalDAVError> {
     // This is a simplified implementation - in a real scenario, you'd want to fetch the specific event by href
     // For now, we'll fetch all events and find the matching one by href (inefficient but functional)
     let events = client.fetch_events(calendar_path).await?;
-    
+
     println!("🔍 fetch_event_by_href: looking for href='{}'", event_href);
-    println!("🔍 Available events with hrefs: {:?}", events.iter().map(|e| (&e.uid, &e.href)).collect::<Vec<_>>());
-    
+    println!(
+        "🔍 Available events with hrefs: {:?}",
+        events.iter().map(|e| (&e.uid, &e.href)).collect::<Vec<_>>()
+    );
+
     // First try to match by exact href
     for event in &events {
         if let Some(stored_href) = &event.href {
@@ -118,22 +142,25 @@ async fn fetch_event_by_href(client: &CalDAVClient, calendar_path: &str, event_h
             }
         }
     }
-    
+
     // Fallback: try to match by UID extracted from href filename
     let filename = event_href.split('/').last().unwrap_or(event_href);
     let uid_from_href = filename.trim_end_matches(".ics");
-    
-    println!("🔍 Fallback: trying UID match. filename='{}', uid='{}'", filename, uid_from_href);
-    
+
+    println!(
+        "🔍 Fallback: trying UID match. filename='{}', uid='{}'",
+        filename, uid_from_href
+    );
+
     for event in events {
         if event.uid == uid_from_href {
             println!("✅ Found matching event by UID: {}", event.uid);
             return Ok(Some(event));
         }
     }
-    
+
     println!("❌ No matching event found for href: {}", event_href);
-    
+
     Ok(None)
 }
 
@@ -146,41 +173,63 @@ pub async fn delete_event(
     let password = extract_password_header(&headers)?;
 
     // Create CalDAV config from token and password
-    let config = state.auth_service.caldav_config_from_token(&token, &password)?;
+    let config = state
+        .auth_service
+        .caldav_config_from_token(&token, &password)?;
     let client = CalDAVClient::new(config);
 
     // Handle different delete actions for recurring events
     match request.delete_action.as_str() {
         "delete_this" => {
-            if let Some(event) = fetch_event_by_href(&client, &request.calendar_path, &request.event_href).await
-                .map_err(|e| ApiError::Internal(format!("Failed to fetch event: {}", e)))? {
-                
+            if let Some(event) =
+                fetch_event_by_href(&client, &request.calendar_path, &request.event_href)
+                    .await
+                    .map_err(|e| ApiError::Internal(format!("Failed to fetch event: {}", e)))?
+            {
                 // Check if this is a recurring event
                 if event.rrule.is_some() && !event.rrule.as_ref().unwrap().is_empty() {
                     // Recurring event - add EXDATE for this occurrence
                     if let Some(occurrence_date) = &request.occurrence_date {
-                        let exception_utc = if let Ok(date) = chrono::DateTime::parse_from_rfc3339(occurrence_date) {
+                        let exception_utc = if let Ok(date) =
+                            chrono::DateTime::parse_from_rfc3339(occurrence_date)
+                        {
                             // RFC3339 format (with time and timezone)
                             date.with_timezone(&chrono::Utc)
-                        } else if let Ok(naive_date) = chrono::NaiveDate::parse_from_str(occurrence_date, "%Y-%m-%d") {
+                        } else if let Ok(naive_date) =
+                            chrono::NaiveDate::parse_from_str(occurrence_date, "%Y-%m-%d")
+                        {
                             // Simple date format (YYYY-MM-DD)
                             naive_date.and_hms_opt(0, 0, 0).unwrap().and_utc()
                         } else {
                             return Err(ApiError::BadRequest(format!("Invalid occurrence date format: {}. Expected RFC3339 or YYYY-MM-DD", occurrence_date)));
                         };
-                        
+
                         let mut updated_event = event;
                         updated_event.exdate.push(exception_utc);
-                        
-                        println!("🔄 Adding EXDATE {} to recurring event {}", exception_utc.format("%Y%m%dT%H%M%SZ"), updated_event.uid);
-                        
+
+                        println!(
+                            "🔄 Adding EXDATE {} to recurring event {}",
+                            exception_utc.format("%Y%m%dT%H%M%SZ"),
+                            updated_event.uid
+                        );
+
                         // Update the event with the new EXDATE
-                        client.update_event(&request.calendar_path, &updated_event, &request.event_href)
+                        client
+                            .update_event(
+                                &request.calendar_path,
+                                &updated_event,
+                                &request.event_href,
+                            )
                             .await
-                            .map_err(|e| ApiError::Internal(format!("Failed to update event with EXDATE: {}", e)))?;
-                        
+                            .map_err(|e| {
+                                ApiError::Internal(format!(
+                                    "Failed to update event with EXDATE: {}",
+                                    e
+                                ))
+                            })?;
+
                         println!("✅ Successfully updated recurring event with EXDATE");
-                        
+
                         Ok(Json(DeleteEventResponse {
                             success: true,
                             message: "Single occurrence deleted successfully".to_string(),
@@ -191,13 +240,16 @@ pub async fn delete_event(
                 } else {
                     // Non-recurring event - delete the entire event
                     println!("🗑️ Deleting non-recurring event: {}", event.uid);
-                    
-                    client.delete_event(&request.calendar_path, &request.event_href)
+
+                    client
+                        .delete_event(&request.calendar_path, &request.event_href)
                         .await
-                        .map_err(|e| ApiError::Internal(format!("Failed to delete event: {}", e)))?;
-                    
+                        .map_err(|e| {
+                            ApiError::Internal(format!("Failed to delete event: {}", e))
+                        })?;
+
                     println!("✅ Successfully deleted non-recurring event");
-                    
+
                     Ok(Json(DeleteEventResponse {
                         success: true,
                         message: "Event deleted successfully".to_string(),
@@ -206,70 +258,99 @@ pub async fn delete_event(
             } else {
                 Err(ApiError::NotFound("Event not found".to_string()))
             }
-        },
+        }
         "delete_following" => {
             // For "this and following" deletion, we need to:
             // 1. Fetch the recurring event
             // 2. Modify the RRULE to end before this occurrence
             // 3. Update the event
 
-            if let Some(mut event) = fetch_event_by_href(&client, &request.calendar_path, &request.event_href).await
-                .map_err(|e| ApiError::Internal(format!("Failed to fetch event: {}", e)))? {
-                
+            if let Some(mut event) =
+                fetch_event_by_href(&client, &request.calendar_path, &request.event_href)
+                    .await
+                    .map_err(|e| ApiError::Internal(format!("Failed to fetch event: {}", e)))?
+            {
                 if let Some(occurrence_date) = &request.occurrence_date {
-                    let until_date = if let Ok(date) = chrono::DateTime::parse_from_rfc3339(occurrence_date) {
+                    let until_date = if let Ok(date) =
+                        chrono::DateTime::parse_from_rfc3339(occurrence_date)
+                    {
                         // RFC3339 format (with time and timezone)
                         date.with_timezone(&chrono::Utc)
-                    } else if let Ok(naive_date) = chrono::NaiveDate::parse_from_str(occurrence_date, "%Y-%m-%d") {
+                    } else if let Ok(naive_date) =
+                        chrono::NaiveDate::parse_from_str(occurrence_date, "%Y-%m-%d")
+                    {
                         // Simple date format (YYYY-MM-DD)
                         naive_date.and_hms_opt(0, 0, 0).unwrap().and_utc()
                     } else {
-                        return Err(ApiError::BadRequest(format!("Invalid occurrence date format: {}. Expected RFC3339 or YYYY-MM-DD", occurrence_date)));
+                        return Err(ApiError::BadRequest(format!(
+                            "Invalid occurrence date format: {}. Expected RFC3339 or YYYY-MM-DD",
+                            occurrence_date
+                        )));
                     };
-                    
+
                     // Modify the RRULE to add an UNTIL clause
                     if let Some(rrule) = &event.rrule {
                         // Remove existing UNTIL if present and add new one
-                        let parts: Vec<&str> = rrule.split(';').filter(|part| {
-                            !part.starts_with("UNTIL=") && !part.starts_with("COUNT=")
-                        }).collect();
-                        
-                        let new_rrule = format!("{};UNTIL={}", parts.join(";"), until_date.format("%Y%m%dT%H%M%SZ"));
+                        let parts: Vec<&str> = rrule
+                            .split(';')
+                            .filter(|part| {
+                                !part.starts_with("UNTIL=") && !part.starts_with("COUNT=")
+                            })
+                            .collect();
+
+                        let new_rrule = format!(
+                            "{};UNTIL={}",
+                            parts.join(";"),
+                            until_date.format("%Y%m%dT%H%M%SZ")
+                        );
                         event.rrule = Some(new_rrule);
-                        
+
                         // Update the event with the modified RRULE
-                        client.update_event(&request.calendar_path, &event, &request.event_href)
+                        client
+                            .update_event(&request.calendar_path, &event, &request.event_href)
                             .await
-                            .map_err(|e| ApiError::Internal(format!("Failed to update event with modified RRULE: {}", e)))?;
-                        
+                            .map_err(|e| {
+                                ApiError::Internal(format!(
+                                    "Failed to update event with modified RRULE: {}",
+                                    e
+                                ))
+                            })?;
+
                         Ok(Json(DeleteEventResponse {
                             success: true,
-                            message: "This and following occurrences deleted successfully".to_string(),
+                            message: "This and following occurrences deleted successfully"
+                                .to_string(),
                         }))
                     } else {
                         // No RRULE, just delete the single event
-                        client.delete_event(&request.calendar_path, &request.event_href)
+                        client
+                            .delete_event(&request.calendar_path, &request.event_href)
                             .await
-                            .map_err(|e| ApiError::Internal(format!("Failed to delete event: {}", e)))?;
-                        
+                            .map_err(|e| {
+                                ApiError::Internal(format!("Failed to delete event: {}", e))
+                            })?;
+
                         Ok(Json(DeleteEventResponse {
                             success: true,
                             message: "Event deleted successfully".to_string(),
                         }))
                     }
                 } else {
-                    Err(ApiError::BadRequest("Occurrence date is required for following deletion".to_string()))
+                    Err(ApiError::BadRequest(
+                        "Occurrence date is required for following deletion".to_string(),
+                    ))
                 }
             } else {
                 Err(ApiError::NotFound("Event not found".to_string()))
             }
-        },
+        }
         "delete_series" | _ => {
             // Delete the entire event/series
-            client.delete_event(&request.calendar_path, &request.event_href)
+            client
+                .delete_event(&request.calendar_path, &request.event_href)
                 .await
                 .map_err(|e| ApiError::Internal(format!("Failed to delete event: {}", e)))?;
-            
+
             Ok(Json(DeleteEventResponse {
                 success: true,
                 message: "Event deleted successfully".to_string(),
@@ -283,9 +364,11 @@ pub async fn create_event(
     headers: HeaderMap,
     Json(request): Json<CreateEventRequest>,
 ) -> Result<Json<CreateEventResponse>, ApiError> {
-    println!("📝 Create event request received: title='{}', all_day={}, calendar_path={:?}", 
-             request.title, request.all_day, request.calendar_path);
-    
+    println!(
+        "📝 Create event request received: title='{}', all_day={}, calendar_path={:?}",
+        request.title, request.all_day, request.calendar_path
+    );
+
     // Extract and verify token
     let token = extract_bearer_token(&headers)?;
     let password = extract_password_header(&headers)?;
@@ -294,13 +377,17 @@ pub async fn create_event(
     if request.title.trim().is_empty() {
         return Err(ApiError::BadRequest("Event title is required".to_string()));
     }
-    
+
     if request.title.len() > 200 {
-        return Err(ApiError::BadRequest("Event title too long (max 200 characters)".to_string()));
+        return Err(ApiError::BadRequest(
+            "Event title too long (max 200 characters)".to_string(),
+        ));
     }
 
     // Create CalDAV config from token and password
-    let config = state.auth_service.caldav_config_from_token(&token, &password)?;
+    let config = state
+        .auth_service
+        .caldav_config_from_token(&token, &password)?;
     let client = CalDAVClient::new(config);
 
     // Determine which calendar to use
@@ -308,31 +395,41 @@ pub async fn create_event(
         path
     } else {
         // Use the first available calendar
-        let calendar_paths = client.discover_calendars()
+        let calendar_paths = client
+            .discover_calendars()
             .await
             .map_err(|e| ApiError::Internal(format!("Failed to discover calendars: {}", e)))?;
-        
+
         if calendar_paths.is_empty() {
-            return Err(ApiError::BadRequest("No calendars available for event creation".to_string()));
+            return Err(ApiError::BadRequest(
+                "No calendars available for event creation".to_string(),
+            ));
         }
-        
+
         calendar_paths[0].clone()
     };
 
     // Parse dates and times
-    let start_datetime = parse_event_datetime(&request.start_date, &request.start_time, request.all_day)
-        .map_err(|e| ApiError::BadRequest(format!("Invalid start date/time: {}", e)))?;
-    
+    let start_datetime =
+        parse_event_datetime(&request.start_date, &request.start_time, request.all_day)
+            .map_err(|e| ApiError::BadRequest(format!("Invalid start date/time: {}", e)))?;
+
     let end_datetime = parse_event_datetime(&request.end_date, &request.end_time, request.all_day)
         .map_err(|e| ApiError::BadRequest(format!("Invalid end date/time: {}", e)))?;
 
     // Validate that end is after start
     if end_datetime <= start_datetime {
-        return Err(ApiError::BadRequest("End date/time must be after start date/time".to_string()));
+        return Err(ApiError::BadRequest(
+            "End date/time must be after start date/time".to_string(),
+        ));
     }
 
     // Generate a unique UID for the event
-    let uid = format!("{}-{}", uuid::Uuid::new_v4(), chrono::Utc::now().timestamp());
+    let uid = format!(
+        "{}-{}",
+        uuid::Uuid::new_v4(),
+        chrono::Utc::now().timestamp()
+    );
 
     // Parse status
     let status = match request.status.to_lowercase().as_str() {
@@ -352,7 +449,8 @@ pub async fn create_event(
     let attendees: Vec<String> = if request.attendees.trim().is_empty() {
         Vec::new()
     } else {
-        request.attendees
+        request
+            .attendees
             .split(',')
             .map(|s| s.trim().to_string())
             .filter(|s| !s.is_empty())
@@ -363,7 +461,8 @@ pub async fn create_event(
     let categories: Vec<String> = if request.categories.trim().is_empty() {
         Vec::new()
     } else {
-        request.categories
+        request
+            .categories
             .split(',')
             .map(|s| s.trim().to_string())
             .filter(|s| !s.is_empty())
@@ -399,10 +498,11 @@ pub async fn create_event(
             "WEEKLY" => {
                 // Handle weekly recurrence with optional BYDAY parameter
                 let mut rrule = "FREQ=WEEKLY".to_string();
-                
+
                 // Check if specific days are selected (recurrence_days has 7 elements: [Sun, Mon, Tue, Wed, Thu, Fri, Sat])
                 if request.recurrence_days.len() == 7 {
-                    let selected_days: Vec<&str> = request.recurrence_days
+                    let selected_days: Vec<&str> = request
+                        .recurrence_days
                         .iter()
                         .enumerate()
                         .filter_map(|(i, &selected)| {
@@ -416,20 +516,20 @@ pub async fn create_event(
                                     5 => "FR", // Friday
                                     6 => "SA", // Saturday
                                     _ => return None,
-                            })
-                        } else {
-                            None
-                        }
-                    })
-                    .collect();
+                                })
+                            } else {
+                                None
+                            }
+                        })
+                        .collect();
 
-                if !selected_days.is_empty() {
-                    rrule = format!("{};BYDAY={}", rrule, selected_days.join(","));
+                    if !selected_days.is_empty() {
+                        rrule = format!("{};BYDAY={}", rrule, selected_days.join(","));
+                    }
                 }
-            }
-            
+
                 Some(rrule)
-            },
+            }
             "MONTHLY" => Some("FREQ=MONTHLY".to_string()),
             "YEARLY" => Some("FREQ=YEARLY".to_string()),
             _ => None,
@@ -439,15 +539,27 @@ pub async fn create_event(
     // Create the VEvent struct (RFC 5545 compliant)
     let mut event = VEvent::new(uid, start_datetime);
     event.dtend = Some(end_datetime);
-    event.summary = if request.title.trim().is_empty() { None } else { Some(request.title.clone()) };
-    event.description = if request.description.trim().is_empty() { None } else { Some(request.description) };
-    event.location = if request.location.trim().is_empty() { None } else { Some(request.location) };
+    event.summary = if request.title.trim().is_empty() {
+        None
+    } else {
+        Some(request.title.clone())
+    };
+    event.description = if request.description.trim().is_empty() {
+        None
+    } else {
+        Some(request.description)
+    };
+    event.location = if request.location.trim().is_empty() {
+        None
+    } else {
+        Some(request.location)
+    };
     event.status = Some(status);
     event.class = Some(class);
     event.priority = request.priority;
-    event.organizer = if request.organizer.trim().is_empty() { 
-        None 
-    } else { 
+    event.organizer = if request.organizer.trim().is_empty() {
+        None
+    } else {
         Some(CalendarUser {
             cal_address: request.organizer,
             common_name: None,
@@ -456,41 +568,53 @@ pub async fn create_event(
             language: None,
         })
     };
-    event.attendees = attendees.into_iter().map(|email| Attendee {
-        cal_address: email,
-        common_name: None,
-        role: None,
-        part_stat: None,
-        rsvp: None,
-        cu_type: None,
-        member: Vec::new(),
-        delegated_to: Vec::new(),
-        delegated_from: Vec::new(),
-        sent_by: None,
-        dir_entry_ref: None,
-        language: None,
-    }).collect();
+    event.attendees = attendees
+        .into_iter()
+        .map(|email| Attendee {
+            cal_address: email,
+            common_name: None,
+            role: None,
+            part_stat: None,
+            rsvp: None,
+            cu_type: None,
+            member: Vec::new(),
+            delegated_to: Vec::new(),
+            delegated_from: Vec::new(),
+            sent_by: None,
+            dir_entry_ref: None,
+            language: None,
+        })
+        .collect();
     event.categories = categories;
     event.rrule = rrule;
     event.all_day = request.all_day;
-    event.alarms = alarms.into_iter().map(|reminder| VAlarm {
-        action: AlarmAction::Display,
-        trigger: AlarmTrigger::Duration(chrono::Duration::minutes(-reminder.minutes_before as i64)),
-        duration: None,
-        repeat: None,
-        description: reminder.description,
-        summary: None,
-        attendees: Vec::new(),
-        attach: Vec::new(),
-    }).collect();
+    event.alarms = alarms
+        .into_iter()
+        .map(|reminder| VAlarm {
+            action: AlarmAction::Display,
+            trigger: AlarmTrigger::Duration(chrono::Duration::minutes(
+                -reminder.minutes_before as i64,
+            )),
+            duration: None,
+            repeat: None,
+            description: reminder.description,
+            summary: None,
+            attendees: Vec::new(),
+            attach: Vec::new(),
+        })
+        .collect();
     event.calendar_path = Some(calendar_path.clone());
 
     // Create the event on the CalDAV server
-    let event_href = client.create_event(&calendar_path, &event)
+    let event_href = client
+        .create_event(&calendar_path, &event)
         .await
         .map_err(|e| ApiError::Internal(format!("Failed to create event: {}", e)))?;
 
-    println!("✅ Event created successfully with UID: {} at href: {}", event.uid, event_href);
+    println!(
+        "✅ Event created successfully with UID: {} at href: {}",
+        event.uid, event_href
+    );
 
     Ok(Json(CreateEventResponse {
         success: true,
@@ -505,7 +629,7 @@ pub async fn update_event(
     Json(request): Json<UpdateEventRequest>,
 ) -> Result<Json<UpdateEventResponse>, ApiError> {
     // Handle update request
-    
+
     // Extract and verify token
     let token = extract_bearer_token(&headers)?;
     let password = extract_password_header(&headers)?;
@@ -514,37 +638,45 @@ pub async fn update_event(
     if request.uid.trim().is_empty() {
         return Err(ApiError::BadRequest("Event UID is required".to_string()));
     }
-    
+
     if request.title.trim().is_empty() {
         return Err(ApiError::BadRequest("Event title is required".to_string()));
     }
-    
+
     if request.title.len() > 200 {
-        return Err(ApiError::BadRequest("Event title too long (max 200 characters)".to_string()));
+        return Err(ApiError::BadRequest(
+            "Event title too long (max 200 characters)".to_string(),
+        ));
     }
 
     // Create CalDAV config from token and password
-    let config = state.auth_service.caldav_config_from_token(&token, &password)?;
+    let config = state
+        .auth_service
+        .caldav_config_from_token(&token, &password)?;
     let client = CalDAVClient::new(config);
 
     // Find the event across all calendars (or in the specified calendar)
     let calendar_paths = if let Some(path) = &request.calendar_path {
         vec![path.clone()]
     } else {
-        client.discover_calendars()
+        client
+            .discover_calendars()
             .await
             .map_err(|e| ApiError::Internal(format!("Failed to discover calendars: {}", e)))?
     };
 
     let mut found_event: Option<(CalendarEvent, String, String)> = None; // (event, calendar_path, event_href)
-    
+
     for calendar_path in &calendar_paths {
         match client.fetch_events(calendar_path).await {
             Ok(events) => {
                 for event in events {
                     if event.uid == request.uid {
                         // Use the actual href from the event, or generate one if missing
-                        let event_href = event.href.clone().unwrap_or_else(|| format!("{}.ics", event.uid));
+                        let event_href = event
+                            .href
+                            .clone()
+                            .unwrap_or_else(|| format!("{}.ics", event.uid));
                         println!("🔍 Found event {} with href: {}", event.uid, event_href);
                         found_event = Some((event, calendar_path.clone(), event_href));
                         break;
@@ -553,9 +685,12 @@ pub async fn update_event(
                 if found_event.is_some() {
                     break;
                 }
-            },
+            }
             Err(e) => {
-                eprintln!("Failed to fetch events from calendar {}: {}", calendar_path, e);
+                eprintln!(
+                    "Failed to fetch events from calendar {}: {}",
+                    calendar_path, e
+                );
                 continue;
             }
         }
@@ -565,23 +700,38 @@ pub async fn update_event(
         .ok_or_else(|| ApiError::NotFound(format!("Event with UID '{}' not found", request.uid)))?;
 
     // Parse dates and times
-    let start_datetime = parse_event_datetime(&request.start_date, &request.start_time, request.all_day)
-        .map_err(|e| ApiError::BadRequest(format!("Invalid start date/time: {}", e)))?;
-    
+    let start_datetime =
+        parse_event_datetime(&request.start_date, &request.start_time, request.all_day)
+            .map_err(|e| ApiError::BadRequest(format!("Invalid start date/time: {}", e)))?;
+
     let end_datetime = parse_event_datetime(&request.end_date, &request.end_time, request.all_day)
         .map_err(|e| ApiError::BadRequest(format!("Invalid end date/time: {}", e)))?;
 
     // Validate that end is after start
     if end_datetime <= start_datetime {
-        return Err(ApiError::BadRequest("End date/time must be after start date/time".to_string()));
+        return Err(ApiError::BadRequest(
+            "End date/time must be after start date/time".to_string(),
+        ));
     }
 
     // Update event properties
     event.dtstart = start_datetime;
     event.dtend = Some(end_datetime);
-    event.summary = if request.title.trim().is_empty() { None } else { Some(request.title) };
-    event.description = if request.description.trim().is_empty() { None } else { Some(request.description) };
-    event.location = if request.location.trim().is_empty() { None } else { Some(request.location) };
+    event.summary = if request.title.trim().is_empty() {
+        None
+    } else {
+        Some(request.title)
+    };
+    event.description = if request.description.trim().is_empty() {
+        None
+    } else {
+        Some(request.description)
+    };
+    event.location = if request.location.trim().is_empty() {
+        None
+    } else {
+        Some(request.location)
+    };
     event.all_day = request.all_day;
 
     // Parse and update status
@@ -601,11 +751,15 @@ pub async fn update_event(
     event.priority = request.priority;
 
     // Update the event on the CalDAV server
-    println!("📝 Updating event {} at calendar_path: {}, event_href: {}", event.uid, calendar_path, event_href);
-    client.update_event(&calendar_path, &event, &event_href)
+    println!(
+        "📝 Updating event {} at calendar_path: {}, event_href: {}",
+        event.uid, calendar_path, event_href
+    );
+    client
+        .update_event(&calendar_path, &event, &event_href)
         .await
         .map_err(|e| ApiError::Internal(format!("Failed to update event: {}", e)))?;
-    
+
     println!("✅ Successfully updated event {}", event.uid);
 
     Ok(Json(UpdateEventResponse {
@@ -614,27 +768,32 @@ pub async fn update_event(
     }))
 }
 
-fn parse_event_datetime(date_str: &str, time_str: &str, all_day: bool) -> Result<chrono::DateTime<chrono::Utc>, String> {
-    use chrono::{NaiveDate, NaiveTime, NaiveDateTime, Utc, TimeZone};
-    
+fn parse_event_datetime(
+    date_str: &str,
+    time_str: &str,
+    all_day: bool,
+) -> Result<chrono::DateTime<chrono::Utc>, String> {
+    use chrono::{NaiveDate, NaiveDateTime, NaiveTime, TimeZone, Utc};
+
     // Parse the date
     let date = NaiveDate::parse_from_str(date_str, "%Y-%m-%d")
         .map_err(|_| format!("Invalid date format: {}. Expected YYYY-MM-DD", date_str))?;
-    
+
     if all_day {
         // For all-day events, use midnight UTC
-        let datetime = date.and_hms_opt(0, 0, 0)
+        let datetime = date
+            .and_hms_opt(0, 0, 0)
             .ok_or_else(|| "Failed to create midnight datetime".to_string())?;
         Ok(Utc.from_utc_datetime(&datetime))
     } else {
         // Parse the time
         let time = NaiveTime::parse_from_str(time_str, "%H:%M")
             .map_err(|_| format!("Invalid time format: {}. Expected HH:MM", time_str))?;
-        
+
         // Combine date and time
         let datetime = NaiveDateTime::new(date, time);
-        
+
         // Assume local time and convert to UTC (in a real app, you'd want timezone support)
         Ok(Utc.from_utc_datetime(&datetime))
     }
-}
\ No newline at end of file
+}
diff --git a/backend/src/handlers/series.rs b/backend/src/handlers/series.rs
index a69c595..945881b 100644
--- a/backend/src/handlers/series.rs
+++ b/backend/src/handlers/series.rs
@@ -1,14 +1,16 @@
-use axum::{
-    extract::State,
-    http::HeaderMap,
-    response::Json,
-};
-use std::sync::Arc;
+use axum::{extract::State, http::HeaderMap, response::Json};
 use chrono::TimeZone;
+use std::sync::Arc;
 
-use crate::{AppState, models::{ApiError, CreateEventSeriesRequest, CreateEventSeriesResponse, UpdateEventSeriesRequest, UpdateEventSeriesResponse, DeleteEventSeriesRequest, DeleteEventSeriesResponse}};
 use crate::calendar::CalDAVClient;
-use calendar_models::{VEvent, EventStatus, EventClass};
+use crate::{
+    models::{
+        ApiError, CreateEventSeriesRequest, CreateEventSeriesResponse, DeleteEventSeriesRequest,
+        DeleteEventSeriesResponse, UpdateEventSeriesRequest, UpdateEventSeriesResponse,
+    },
+    AppState,
+};
+use calendar_models::{EventClass, EventStatus, VEvent};
 
 use super::auth::{extract_bearer_token, extract_password_header};
 
@@ -18,9 +20,11 @@ pub async fn create_event_series(
     headers: HeaderMap,
     Json(request): Json<CreateEventSeriesRequest>,
 ) -> Result<Json<CreateEventSeriesResponse>, ApiError> {
-    println!("📝 Create event series request received: title='{}', recurrence='{}', all_day={}", 
-             request.title, request.recurrence, request.all_day);
-    
+    println!(
+        "📝 Create event series request received: title='{}', recurrence='{}', all_day={}",
+        request.title, request.recurrence, request.all_day
+    );
+
     // Extract and verify token
     let token = extract_bearer_token(&headers)?;
     let password = extract_password_header(&headers)?;
@@ -29,13 +33,17 @@ pub async fn create_event_series(
     if request.title.trim().is_empty() {
         return Err(ApiError::BadRequest("Event title is required".to_string()));
     }
-    
+
     if request.title.len() > 200 {
-        return Err(ApiError::BadRequest("Event title too long (max 200 characters)".to_string()));
+        return Err(ApiError::BadRequest(
+            "Event title too long (max 200 characters)".to_string(),
+        ));
     }
 
     if request.recurrence == "none" {
-        return Err(ApiError::BadRequest("Use regular create endpoint for non-recurring events".to_string()));
+        return Err(ApiError::BadRequest(
+            "Use regular create endpoint for non-recurring events".to_string(),
+        ));
     }
 
     // Validate recurrence type - handle both simple strings and RRULE strings
@@ -50,7 +58,9 @@ pub async fn create_event_series(
         } else if request.recurrence.contains("FREQ=YEARLY") {
             "yearly"
         } else {
-            return Err(ApiError::BadRequest("Invalid RRULE frequency. Must be DAILY, WEEKLY, MONTHLY, or YEARLY".to_string()));
+            return Err(ApiError::BadRequest(
+                "Invalid RRULE frequency. Must be DAILY, WEEKLY, MONTHLY, or YEARLY".to_string(),
+            ));
         }
     } else {
         // Handle simple strings
@@ -58,14 +68,21 @@ pub async fn create_event_series(
         match lower.as_str() {
             "daily" => "daily",
             "weekly" => "weekly",
-            "monthly" => "monthly", 
+            "monthly" => "monthly",
             "yearly" => "yearly",
-            _ => return Err(ApiError::BadRequest("Invalid recurrence type. Must be daily, weekly, monthly, or yearly".to_string())),
+            _ => {
+                return Err(ApiError::BadRequest(
+                    "Invalid recurrence type. Must be daily, weekly, monthly, or yearly"
+                        .to_string(),
+                ))
+            }
         }
     };
 
     // Create CalDAV config from token and password
-    let config = state.auth_service.caldav_config_from_token(&token, &password)?;
+    let config = state
+        .auth_service
+        .caldav_config_from_token(&token, &password)?;
     let client = CalDAVClient::new(config);
 
     // Determine which calendar to use
@@ -73,51 +90,64 @@ pub async fn create_event_series(
         path.clone()
     } else {
         // Use the first available calendar
-        let calendar_paths = client.discover_calendars()
+        let calendar_paths = client
+            .discover_calendars()
             .await
             .map_err(|e| ApiError::Internal(format!("Failed to discover calendars: {}", e)))?;
-        
+
         if calendar_paths.is_empty() {
-            return Err(ApiError::BadRequest("No calendars available for event creation".to_string()));
+            return Err(ApiError::BadRequest(
+                "No calendars available for event creation".to_string(),
+            ));
         }
-        
+
         calendar_paths[0].clone()
     };
 
     println!("📅 Using calendar path: {}", calendar_path);
 
     // Parse datetime components
-    let start_date = chrono::NaiveDate::parse_from_str(&request.start_date, "%Y-%m-%d")
-        .map_err(|_| ApiError::BadRequest("Invalid start_date format. Expected YYYY-MM-DD".to_string()))?;
+    let start_date =
+        chrono::NaiveDate::parse_from_str(&request.start_date, "%Y-%m-%d").map_err(|_| {
+            ApiError::BadRequest("Invalid start_date format. Expected YYYY-MM-DD".to_string())
+        })?;
 
     let (start_datetime, end_datetime) = if request.all_day {
         // For all-day events, use the dates as-is
-        let start_dt = start_date.and_hms_opt(0, 0, 0)
+        let start_dt = start_date
+            .and_hms_opt(0, 0, 0)
             .ok_or_else(|| ApiError::BadRequest("Invalid start date".to_string()))?;
-        
+
         let end_date = if !request.end_date.is_empty() {
-            chrono::NaiveDate::parse_from_str(&request.end_date, "%Y-%m-%d")
-                .map_err(|_| ApiError::BadRequest("Invalid end_date format. Expected YYYY-MM-DD".to_string()))?
+            chrono::NaiveDate::parse_from_str(&request.end_date, "%Y-%m-%d").map_err(|_| {
+                ApiError::BadRequest("Invalid end_date format. Expected YYYY-MM-DD".to_string())
+            })?
         } else {
             start_date
         };
-        
-        let end_dt = end_date.and_hms_opt(23, 59, 59)
+
+        let end_dt = end_date
+            .and_hms_opt(23, 59, 59)
             .ok_or_else(|| ApiError::BadRequest("Invalid end date".to_string()))?;
 
-        (chrono::Utc.from_utc_datetime(&start_dt), chrono::Utc.from_utc_datetime(&end_dt))
+        (
+            chrono::Utc.from_utc_datetime(&start_dt),
+            chrono::Utc.from_utc_datetime(&end_dt),
+        )
     } else {
         // Parse times for timed events
         let start_time = if !request.start_time.is_empty() {
-            chrono::NaiveTime::parse_from_str(&request.start_time, "%H:%M")
-                .map_err(|_| ApiError::BadRequest("Invalid start_time format. Expected HH:MM".to_string()))?
+            chrono::NaiveTime::parse_from_str(&request.start_time, "%H:%M").map_err(|_| {
+                ApiError::BadRequest("Invalid start_time format. Expected HH:MM".to_string())
+            })?
         } else {
             chrono::NaiveTime::from_hms_opt(9, 0, 0).unwrap() // Default to 9 AM
         };
 
         let end_time = if !request.end_time.is_empty() {
-            chrono::NaiveTime::parse_from_str(&request.end_time, "%H:%M")
-                .map_err(|_| ApiError::BadRequest("Invalid end_time format. Expected HH:MM".to_string()))?
+            chrono::NaiveTime::parse_from_str(&request.end_time, "%H:%M").map_err(|_| {
+                ApiError::BadRequest("Invalid end_time format. Expected HH:MM".to_string())
+            })?
         } else {
             chrono::NaiveTime::from_hms_opt(10, 0, 0).unwrap() // Default to 1 hour duration
         };
@@ -125,13 +155,18 @@ pub async fn create_event_series(
         let start_dt = start_date.and_time(start_time);
         let end_dt = if !request.end_date.is_empty() {
             let end_date = chrono::NaiveDate::parse_from_str(&request.end_date, "%Y-%m-%d")
-                .map_err(|_| ApiError::BadRequest("Invalid end_date format. Expected YYYY-MM-DD".to_string()))?;
+                .map_err(|_| {
+                    ApiError::BadRequest("Invalid end_date format. Expected YYYY-MM-DD".to_string())
+                })?;
             end_date.and_time(end_time)
         } else {
             start_date.and_time(end_time)
         };
 
-        (chrono::Utc.from_utc_datetime(&start_dt), chrono::Utc.from_utc_datetime(&end_dt))
+        (
+            chrono::Utc.from_utc_datetime(&start_dt),
+            chrono::Utc.from_utc_datetime(&end_dt),
+        )
     };
 
     // Generate a unique UID for the series
@@ -140,24 +175,36 @@ pub async fn create_event_series(
     // Create the VEvent for the series
     let mut event = VEvent::new(uid.clone(), start_datetime);
     event.dtend = Some(end_datetime);
-    event.summary = if request.title.trim().is_empty() { None } else { Some(request.title.clone()) };
-    event.description = if request.description.trim().is_empty() { None } else { Some(request.description.clone()) };
-    event.location = if request.location.trim().is_empty() { None } else { Some(request.location.clone()) };
-    
+    event.summary = if request.title.trim().is_empty() {
+        None
+    } else {
+        Some(request.title.clone())
+    };
+    event.description = if request.description.trim().is_empty() {
+        None
+    } else {
+        Some(request.description.clone())
+    };
+    event.location = if request.location.trim().is_empty() {
+        None
+    } else {
+        Some(request.location.clone())
+    };
+
     // Set event status
     event.status = Some(match request.status.to_lowercase().as_str() {
         "tentative" => EventStatus::Tentative,
         "cancelled" => EventStatus::Cancelled,
         _ => EventStatus::Confirmed,
     });
-    
+
     // Set event class
     event.class = Some(match request.class.to_lowercase().as_str() {
         "private" => EventClass::Private,
         "confidential" => EventClass::Confidential,
         _ => EventClass::Public,
     });
-    
+
     // Set priority
     event.priority = request.priority;
 
@@ -171,13 +218,16 @@ pub async fn create_event_series(
     };
     event.rrule = Some(rrule);
 
-
     // Create the event on the CalDAV server
-    let event_href = client.create_event(&calendar_path, &event)
+    let event_href = client
+        .create_event(&calendar_path, &event)
         .await
         .map_err(|e| ApiError::Internal(format!("Failed to create event series: {}", e)))?;
 
-    println!("✅ Event series created successfully with UID: {}, href: {}", uid, event_href);
+    println!(
+        "✅ Event series created successfully with UID: {}, href: {}",
+        uid, event_href
+    );
 
     Ok(Json(CreateEventSeriesResponse {
         success: true,
@@ -194,9 +244,11 @@ pub async fn update_event_series(
     headers: HeaderMap,
     Json(request): Json<UpdateEventSeriesRequest>,
 ) -> Result<Json<UpdateEventSeriesResponse>, ApiError> {
-    println!("🔄 Update event series request received: series_uid='{}', update_scope='{}'", 
-             request.series_uid, request.update_scope);
-    
+    println!(
+        "🔄 Update event series request received: series_uid='{}', update_scope='{}'",
+        request.series_uid, request.update_scope
+    );
+
     // Extract and verify token
     let token = extract_bearer_token(&headers)?;
     let password = extract_password_header(&headers)?;
@@ -205,19 +257,26 @@ pub async fn update_event_series(
     if request.series_uid.trim().is_empty() {
         return Err(ApiError::BadRequest("Series UID is required".to_string()));
     }
-    
+
     if request.title.trim().is_empty() {
         return Err(ApiError::BadRequest("Event title is required".to_string()));
     }
-    
+
     if request.title.len() > 200 {
-        return Err(ApiError::BadRequest("Event title too long (max 200 characters)".to_string()));
+        return Err(ApiError::BadRequest(
+            "Event title too long (max 200 characters)".to_string(),
+        ));
     }
 
     // Validate update scope
     match request.update_scope.as_str() {
-        "this_only" | "this_and_future" | "all_in_series" => {},
-        _ => return Err(ApiError::BadRequest("Invalid update_scope. Must be: this_only, this_and_future, or all_in_series".to_string())),
+        "this_only" | "this_and_future" | "all_in_series" => {}
+        _ => {
+            return Err(ApiError::BadRequest(
+                "Invalid update_scope. Must be: this_only, this_and_future, or all_in_series"
+                    .to_string(),
+            ))
+        }
     }
 
     // Validate recurrence type - handle both simple strings and RRULE strings
@@ -232,24 +291,33 @@ pub async fn update_event_series(
         } else if request.recurrence.contains("FREQ=YEARLY") {
             "yearly"
         } else {
-            return Err(ApiError::BadRequest("Invalid RRULE frequency. Must be DAILY, WEEKLY, MONTHLY, or YEARLY".to_string()));
+            return Err(ApiError::BadRequest(
+                "Invalid RRULE frequency. Must be DAILY, WEEKLY, MONTHLY, or YEARLY".to_string(),
+            ));
         }
     } else {
         // Handle simple strings
         let lower = request.recurrence.to_lowercase();
         match lower.as_str() {
             "daily" => "daily",
-            "weekly" => "weekly", 
+            "weekly" => "weekly",
             "monthly" => "monthly",
             "yearly" => "yearly",
-            _ => return Err(ApiError::BadRequest("Invalid recurrence type. Must be daily, weekly, monthly, or yearly".to_string())),
+            _ => {
+                return Err(ApiError::BadRequest(
+                    "Invalid recurrence type. Must be daily, weekly, monthly, or yearly"
+                        .to_string(),
+                ))
+            }
         }
     };
 
     // Create CalDAV config from token and password
-    let config = state.auth_service.caldav_config_from_token(&token, &password)?;
+    let config = state
+        .auth_service
+        .caldav_config_from_token(&token, &password)?;
     let client = CalDAVClient::new(config);
-    
+
     // Use the parsed frequency for further processing (avoiding unused variable warning)
     let _freq_for_processing = recurrence_freq;
 
@@ -257,13 +325,16 @@ pub async fn update_event_series(
     let calendar_paths = if let Some(ref path) = request.calendar_path {
         vec![path.clone()]
     } else {
-        client.discover_calendars()
+        client
+            .discover_calendars()
             .await
             .map_err(|e| ApiError::Internal(format!("Failed to discover calendars: {}", e)))?
     };
 
     if calendar_paths.is_empty() {
-        return Err(ApiError::BadRequest("No calendars available for event update".to_string()));
+        return Err(ApiError::BadRequest(
+            "No calendars available for event update".to_string(),
+        ));
     }
 
     // Find the series event across all specified calendars
@@ -278,60 +349,79 @@ pub async fn update_event_series(
         }
     }
 
-    let mut existing_event = existing_event
-        .ok_or_else(|| ApiError::NotFound(format!("Event series with UID '{}' not found", request.series_uid)))?;
+    let mut existing_event = existing_event.ok_or_else(|| {
+        ApiError::NotFound(format!(
+            "Event series with UID '{}' not found",
+            request.series_uid
+        ))
+    })?;
 
     println!("📅 Found series event in calendar: {}", calendar_path);
-    println!("📅 Event details: UID={}, summary={:?}, dtstart={}", 
-             existing_event.uid, existing_event.summary, existing_event.dtstart);
+    println!(
+        "📅 Event details: UID={}, summary={:?}, dtstart={}",
+        existing_event.uid, existing_event.summary, existing_event.dtstart
+    );
 
     // Parse datetime components for the update
     let original_start_date = existing_event.dtstart.date_naive();
-    
+
     // For "this_and_future" and "this_only" updates, use the occurrence date for the modified event
     // For "all_in_series" updates, preserve the original series start date
-    let start_date = if (request.update_scope == "this_and_future" || request.update_scope == "this_only") && request.occurrence_date.is_some() {
+    let start_date = if (request.update_scope == "this_and_future"
+        || request.update_scope == "this_only")
+        && request.occurrence_date.is_some()
+    {
         let occurrence_date_str = request.occurrence_date.as_ref().unwrap();
-        chrono::NaiveDate::parse_from_str(occurrence_date_str, "%Y-%m-%d")
-            .map_err(|_| ApiError::BadRequest("Invalid occurrence_date format. Expected YYYY-MM-DD".to_string()))?
+        chrono::NaiveDate::parse_from_str(occurrence_date_str, "%Y-%m-%d").map_err(|_| {
+            ApiError::BadRequest("Invalid occurrence_date format. Expected YYYY-MM-DD".to_string())
+        })?
     } else {
         original_start_date
     };
 
     let (start_datetime, end_datetime) = if request.all_day {
-        let start_dt = start_date.and_hms_opt(0, 0, 0)
+        let start_dt = start_date
+            .and_hms_opt(0, 0, 0)
             .ok_or_else(|| ApiError::BadRequest("Invalid start date".to_string()))?;
-        
-        // For all-day events, also preserve the original date pattern  
+
+        // For all-day events, also preserve the original date pattern
         let end_date = if !request.end_date.is_empty() {
             // Calculate the duration from the original event
-            let original_duration_days = existing_event.dtend
+            let original_duration_days = existing_event
+                .dtend
                 .map(|end| (end.date_naive() - existing_event.dtstart.date_naive()).num_days())
                 .unwrap_or(0);
             start_date + chrono::Duration::days(original_duration_days)
         } else {
             start_date
         };
-        
-        let end_dt = end_date.and_hms_opt(23, 59, 59)
+
+        let end_dt = end_date
+            .and_hms_opt(23, 59, 59)
             .ok_or_else(|| ApiError::BadRequest("Invalid end date".to_string()))?;
 
-        (chrono::Utc.from_utc_datetime(&start_dt), chrono::Utc.from_utc_datetime(&end_dt))
+        (
+            chrono::Utc.from_utc_datetime(&start_dt),
+            chrono::Utc.from_utc_datetime(&end_dt),
+        )
     } else {
         let start_time = if !request.start_time.is_empty() {
-            chrono::NaiveTime::parse_from_str(&request.start_time, "%H:%M")
-                .map_err(|_| ApiError::BadRequest("Invalid start_time format. Expected HH:MM".to_string()))?
+            chrono::NaiveTime::parse_from_str(&request.start_time, "%H:%M").map_err(|_| {
+                ApiError::BadRequest("Invalid start_time format. Expected HH:MM".to_string())
+            })?
         } else {
             existing_event.dtstart.time()
         };
 
         let end_time = if !request.end_time.is_empty() {
-            chrono::NaiveTime::parse_from_str(&request.end_time, "%H:%M")
-                .map_err(|_| ApiError::BadRequest("Invalid end_time format. Expected HH:MM".to_string()))?
+            chrono::NaiveTime::parse_from_str(&request.end_time, "%H:%M").map_err(|_| {
+                ApiError::BadRequest("Invalid end_time format. Expected HH:MM".to_string())
+            })?
         } else {
-            existing_event.dtend.map(|dt| dt.time()).unwrap_or_else(|| {
-                existing_event.dtstart.time() + chrono::Duration::hours(1)
-            })
+            existing_event
+                .dtend
+                .map(|dt| dt.time())
+                .unwrap_or_else(|| existing_event.dtstart.time() + chrono::Duration::hours(1))
         };
 
         let start_dt = start_date.and_time(start_time);
@@ -340,13 +430,17 @@ pub async fn update_event_series(
             start_date.and_time(end_time)
         } else {
             // Calculate end time based on original duration
-            let original_duration = existing_event.dtend
+            let original_duration = existing_event
+                .dtend
                 .map(|end| end - existing_event.dtstart)
                 .unwrap_or_else(|| chrono::Duration::hours(1));
             (chrono::Utc.from_utc_datetime(&start_dt) + original_duration).naive_utc()
         };
 
-        (chrono::Utc.from_utc_datetime(&start_dt), chrono::Utc.from_utc_datetime(&end_dt))
+        (
+            chrono::Utc.from_utc_datetime(&start_dt),
+            chrono::Utc.from_utc_datetime(&end_dt),
+        )
     };
 
     // Handle different update scopes
@@ -354,39 +448,73 @@ pub async fn update_event_series(
         "all_in_series" => {
             // Update the entire series - modify the master event
             update_entire_series(&mut existing_event, &request, start_datetime, end_datetime)?
-        },
+        }
         "this_and_future" => {
             // Split the series: keep past occurrences, create new series from occurrence date
-            update_this_and_future(&mut existing_event, &request, start_datetime, end_datetime, &client, &calendar_path).await?
-        },
+            update_this_and_future(
+                &mut existing_event,
+                &request,
+                start_datetime,
+                end_datetime,
+                &client,
+                &calendar_path,
+            )
+            .await?
+        }
         "this_only" => {
             // Create exception for single occurrence, keep original series
-            let event_href = existing_event.href.as_ref()
-                .ok_or_else(|| ApiError::Internal("Event missing href for single occurrence update".to_string()))?
+            let event_href = existing_event
+                .href
+                .as_ref()
+                .ok_or_else(|| {
+                    ApiError::Internal(
+                        "Event missing href for single occurrence update".to_string(),
+                    )
+                })?
                 .clone();
-            update_single_occurrence(&mut existing_event, &request, start_datetime, end_datetime, &client, &calendar_path, &event_href).await?
-        },
+            update_single_occurrence(
+                &mut existing_event,
+                &request,
+                start_datetime,
+                end_datetime,
+                &client,
+                &calendar_path,
+                &event_href,
+            )
+            .await?
+        }
         _ => unreachable!(), // Already validated above
     };
 
     // Update the event on the CalDAV server using the original event's href
     println!("📤 Updating event on CalDAV server...");
-    let event_href = existing_event.href.as_ref()
+    let event_href = existing_event
+        .href
+        .as_ref()
         .ok_or_else(|| ApiError::Internal("Event missing href for update".to_string()))?;
     println!("📤 Using event href: {}", event_href);
     println!("📤 Calendar path: {}", calendar_path);
-    
-    match client.update_event(&calendar_path, &updated_event, event_href).await {
+
+    match client
+        .update_event(&calendar_path, &updated_event, event_href)
+        .await
+    {
         Ok(_) => {
             println!("✅ CalDAV update completed successfully");
         }
         Err(e) => {
             println!("❌ CalDAV update failed: {}", e);
-            return Err(ApiError::Internal(format!("Failed to update event series: {}", e)));
+            return Err(ApiError::Internal(format!(
+                "Failed to update event series: {}",
+                e
+            )));
         }
     }
 
-    println!("✅ Event series updated successfully with UID: {}", request.series_uid);
+    println!(
+        "✅ Event series updated successfully with UID: {}",
+        request.series_uid
+    );
 
     Ok(Json(UpdateEventSeriesResponse {
         success: true,
@@ -402,9 +530,11 @@ pub async fn delete_event_series(
     headers: HeaderMap,
     Json(request): Json<DeleteEventSeriesRequest>,
 ) -> Result<Json<DeleteEventSeriesResponse>, ApiError> {
-    println!("🗑️ Delete event series request received: series_uid='{}', delete_scope='{}'", 
-             request.series_uid, request.delete_scope);
-    
+    println!(
+        "🗑️ Delete event series request received: series_uid='{}', delete_scope='{}'",
+        request.series_uid, request.delete_scope
+    );
+
     // Extract and verify token
     let token = extract_bearer_token(&headers)?;
     let password = extract_password_header(&headers)?;
@@ -413,9 +543,11 @@ pub async fn delete_event_series(
     if request.series_uid.trim().is_empty() {
         return Err(ApiError::BadRequest("Series UID is required".to_string()));
     }
-    
+
     if request.calendar_path.trim().is_empty() {
-        return Err(ApiError::BadRequest("Calendar path is required".to_string()));
+        return Err(ApiError::BadRequest(
+            "Calendar path is required".to_string(),
+        ));
     }
 
     if request.event_href.trim().is_empty() {
@@ -424,12 +556,19 @@ pub async fn delete_event_series(
 
     // Validate delete scope
     match request.delete_scope.as_str() {
-        "this_only" | "this_and_future" | "all_in_series" => {},
-        _ => return Err(ApiError::BadRequest("Invalid delete_scope. Must be: this_only, this_and_future, or all_in_series".to_string())),
+        "this_only" | "this_and_future" | "all_in_series" => {}
+        _ => {
+            return Err(ApiError::BadRequest(
+                "Invalid delete_scope. Must be: this_only, this_and_future, or all_in_series"
+                    .to_string(),
+            ))
+        }
     }
 
     // Create CalDAV config from token and password
-    let config = state.auth_service.caldav_config_from_token(&token, &password)?;
+    let config = state
+        .auth_service
+        .caldav_config_from_token(&token, &password)?;
     let client = CalDAVClient::new(config);
 
     // Handle different deletion scopes
@@ -437,19 +576,22 @@ pub async fn delete_event_series(
         "all_in_series" => {
             // Delete the entire series - simply delete the event
             delete_entire_series(&client, &request).await?
-        },
+        }
         "this_and_future" => {
             // Modify RRULE to end before this occurrence
             delete_this_and_future(&client, &request).await?
-        },
+        }
         "this_only" => {
             // Add EXDATE for single occurrence
             delete_single_occurrence(&client, &request).await?
-        },
+        }
         _ => unreachable!(), // Already validated above
     };
 
-    println!("✅ Event series deletion completed with {} occurrences affected", occurrences_affected);
+    println!(
+        "✅ Event series deletion completed with {} occurrences affected",
+        occurrences_affected
+    );
 
     Ok(Json(DeleteEventSeriesResponse {
         success: true,
@@ -460,29 +602,36 @@ pub async fn delete_event_series(
 
 // Helper functions
 
-
-fn build_series_rrule_with_freq(request: &CreateEventSeriesRequest, freq: &str) -> Result<String, ApiError> {
+fn build_series_rrule_with_freq(
+    request: &CreateEventSeriesRequest,
+    freq: &str,
+) -> Result<String, ApiError> {
     let mut rrule_parts = Vec::new();
-    
+
     // Add frequency
     match freq {
         "daily" => rrule_parts.push("FREQ=DAILY".to_string()),
         "weekly" => rrule_parts.push("FREQ=WEEKLY".to_string()),
         "monthly" => rrule_parts.push("FREQ=MONTHLY".to_string()),
         "yearly" => rrule_parts.push("FREQ=YEARLY".to_string()),
-        _ => return Err(ApiError::BadRequest("Invalid recurrence frequency".to_string())),
+        _ => {
+            return Err(ApiError::BadRequest(
+                "Invalid recurrence frequency".to_string(),
+            ))
+        }
     }
-    
+
     // Add interval if specified and greater than 1
     if let Some(interval) = request.recurrence_interval {
         if interval > 1 {
             rrule_parts.push(format!("INTERVAL={}", interval));
         }
     }
-    
+
     // Handle weekly recurrence with specific days (BYDAY)
     if freq == "weekly" && request.recurrence_days.len() == 7 {
-        let selected_days: Vec<&str> = request.recurrence_days
+        let selected_days: Vec<&str> = request
+            .recurrence_days
             .iter()
             .enumerate()
             .filter_map(|(i, &selected)| {
@@ -507,25 +656,30 @@ fn build_series_rrule_with_freq(request: &CreateEventSeriesRequest, freq: &str)
             rrule_parts.push(format!("BYDAY={}", selected_days.join(",")));
         }
     }
-    
+
     // Add end date if specified (UNTIL takes precedence over COUNT)
     if let Some(end_date) = &request.recurrence_end_date {
         // Parse the end date and convert to RRULE format (YYYYMMDDTHHMMSSZ)
         match chrono::NaiveDate::parse_from_str(end_date, "%Y-%m-%d") {
             Ok(date) => {
-                let end_datetime = date.and_hms_opt(23, 59, 59)
+                let end_datetime = date
+                    .and_hms_opt(23, 59, 59)
                     .ok_or_else(|| ApiError::BadRequest("Invalid end date".to_string()))?;
                 let utc_end = chrono::Utc.from_utc_datetime(&end_datetime);
                 rrule_parts.push(format!("UNTIL={}", utc_end.format("%Y%m%dT%H%M%SZ")));
-            },
-            Err(_) => return Err(ApiError::BadRequest("Invalid recurrence_end_date format. Expected YYYY-MM-DD".to_string())),
+            }
+            Err(_) => {
+                return Err(ApiError::BadRequest(
+                    "Invalid recurrence_end_date format. Expected YYYY-MM-DD".to_string(),
+                ))
+            }
         }
     } else if let Some(count) = request.recurrence_count {
         if count > 0 {
             rrule_parts.push(format!("COUNT={}", count));
         }
     }
-    
+
     Ok(rrule_parts.join(";"))
 }
 
@@ -538,38 +692,38 @@ fn update_entire_series(
 ) -> Result<(VEvent, u32), ApiError> {
     // Clone the existing event to preserve all metadata
     let mut updated_event = existing_event.clone();
-    
+
     // Update only the modified properties from the request
     updated_event.dtstart = start_datetime;
     updated_event.dtend = Some(end_datetime);
-    updated_event.summary = if request.title.trim().is_empty() { 
-        existing_event.summary.clone()  // Keep original if empty
-    } else { 
-        Some(request.title.clone()) 
+    updated_event.summary = if request.title.trim().is_empty() {
+        existing_event.summary.clone() // Keep original if empty
+    } else {
+        Some(request.title.clone())
     };
-    updated_event.description = if request.description.trim().is_empty() { 
-        existing_event.description.clone()  // Keep original if empty
-    } else { 
-        Some(request.description.clone()) 
+    updated_event.description = if request.description.trim().is_empty() {
+        existing_event.description.clone() // Keep original if empty
+    } else {
+        Some(request.description.clone())
     };
-    updated_event.location = if request.location.trim().is_empty() { 
-        existing_event.location.clone()  // Keep original if empty
-    } else { 
-        Some(request.location.clone()) 
+    updated_event.location = if request.location.trim().is_empty() {
+        existing_event.location.clone() // Keep original if empty
+    } else {
+        Some(request.location.clone())
     };
-    
+
     updated_event.status = Some(match request.status.to_lowercase().as_str() {
         "tentative" => EventStatus::Tentative,
         "cancelled" => EventStatus::Cancelled,
         _ => EventStatus::Confirmed,
     });
-    
+
     updated_event.class = Some(match request.class.to_lowercase().as_str() {
         "private" => EventClass::Private,
         "confidential" => EventClass::Confidential,
         _ => EventClass::Public,
     });
-    
+
     updated_event.priority = request.priority;
 
     // Update timestamps
@@ -589,14 +743,14 @@ fn update_entire_series(
 }
 
 /// Update this occurrence and all future occurrences (RFC 5545 compliant series splitting)
-/// 
-/// This function implements the "this and future events" modification pattern for recurring 
+///
+/// This function implements the "this and future events" modification pattern for recurring
 /// event series by splitting the original series into two parts:
 ///
 /// ## Operation Overview:
 /// 1. **Terminate Original Series**: Adds an UNTIL clause to the original recurring event
 ///    to stop generating occurrences before the target occurrence date.
-/// 2. **Create New Series**: Creates a completely new recurring series starting from the 
+/// 2. **Create New Series**: Creates a completely new recurring series starting from the
 ///    target occurrence date with the updated properties (new times, title, etc.).
 ///
 /// ## Example Scenario:
@@ -616,7 +770,7 @@ fn update_entire_series(
 /// This function performs two sequential CalDAV operations:
 /// 1. CREATE new series on the CalDAV server
 /// 2. UPDATE original series (handled by caller) with UNTIL clause
-/// 
+///
 /// Operations are serialized using a global mutex to prevent race conditions.
 ///
 /// ## Parameters:
@@ -641,73 +795,104 @@ async fn update_this_and_future(
     client: &CalDAVClient,
     calendar_path: &str,
 ) -> Result<(VEvent, u32), ApiError> {
-    
     // Clone the existing event to create the new series before modifying the RRULE of the
     // original, because we'd like to preserve the original UNTIL logic
     let mut new_series = existing_event.clone();
-    let occurrence_date = request.occurrence_date.as_ref()
-        .ok_or_else(|| ApiError::BadRequest("occurrence_date is required for this_and_future updates".to_string()))?;
-    
+    let occurrence_date = request.occurrence_date.as_ref().ok_or_else(|| {
+        ApiError::BadRequest("occurrence_date is required for this_and_future updates".to_string())
+    })?;
+
     // Parse occurrence date
     let occurrence_date_parsed = chrono::NaiveDate::parse_from_str(occurrence_date, "%Y-%m-%d")
         .map_err(|_| ApiError::BadRequest("Invalid occurrence date format".to_string()))?;
-    
+
     // Step 1: Add UNTIL to the original series to stop before the occurrence date
-    let until_datetime = occurrence_date_parsed.and_hms_opt(0, 0, 0)
+    let until_datetime = occurrence_date_parsed
+        .and_hms_opt(0, 0, 0)
         .ok_or_else(|| ApiError::BadRequest("Invalid occurrence date".to_string()))?;
     let utc_until = chrono::Utc.from_utc_datetime(&until_datetime);
-    
+
     // Create modified RRULE with UNTIL clause for the original series
-    let original_rrule = existing_event.rrule.clone().unwrap_or_else(|| "FREQ=WEEKLY".to_string());
-    let parts: Vec<&str> = original_rrule.split(';').filter(|part| {
-        !part.starts_with("UNTIL=") && !part.starts_with("COUNT=")
-    }).collect();
-    
-    existing_event.rrule = Some(format!("{};UNTIL={}", parts.join(";"), utc_until.format("%Y%m%dT%H%M%SZ")));
-    println!("🔄 this_and_future: Updated original series RRULE: {:?}", existing_event.rrule);
-    
+    let original_rrule = existing_event
+        .rrule
+        .clone()
+        .unwrap_or_else(|| "FREQ=WEEKLY".to_string());
+    let parts: Vec<&str> = original_rrule
+        .split(';')
+        .filter(|part| !part.starts_with("UNTIL=") && !part.starts_with("COUNT="))
+        .collect();
+
+    existing_event.rrule = Some(format!(
+        "{};UNTIL={}",
+        parts.join(";"),
+        utc_until.format("%Y%m%dT%H%M%SZ")
+    ));
+    println!(
+        "🔄 this_and_future: Updated original series RRULE: {:?}",
+        existing_event.rrule
+    );
+
     // Step 2: Create a new series starting from the occurrence date with updated properties
     let new_series_uid = format!("series-{}", uuid::Uuid::new_v4());
-    
+
     // Update the new series with new properties
     new_series.uid = new_series_uid.clone();
     new_series.dtstart = start_datetime;
     new_series.dtend = Some(end_datetime);
-    new_series.summary = if request.title.trim().is_empty() { None } else { Some(request.title.clone()) };
-    new_series.description = if request.description.trim().is_empty() { None } else { Some(request.description.clone()) };
-    new_series.location = if request.location.trim().is_empty() { None } else { Some(request.location.clone()) };
-    
+    new_series.summary = if request.title.trim().is_empty() {
+        None
+    } else {
+        Some(request.title.clone())
+    };
+    new_series.description = if request.description.trim().is_empty() {
+        None
+    } else {
+        Some(request.description.clone())
+    };
+    new_series.location = if request.location.trim().is_empty() {
+        None
+    } else {
+        Some(request.location.clone())
+    };
+
     new_series.status = Some(match request.status.to_lowercase().as_str() {
         "tentative" => EventStatus::Tentative,
         "cancelled" => EventStatus::Cancelled,
         _ => EventStatus::Confirmed,
     });
-    
+
     new_series.class = Some(match request.class.to_lowercase().as_str() {
         "private" => EventClass::Private,
         "confidential" => EventClass::Confidential,
         _ => EventClass::Public,
     });
-    
+
     new_series.priority = request.priority;
-    
+
     // Update timestamps
     let now = chrono::Utc::now();
     new_series.dtstamp = now;
     new_series.created = Some(now);
     new_series.last_modified = Some(now);
     new_series.href = None; // Will be set when created
-    
-    println!("🔄 this_and_future: Creating new series with UID: {}", new_series_uid);
-    println!("🔄 this_and_future: New series RRULE: {:?}", new_series.rrule);
-    
+
+    println!(
+        "🔄 this_and_future: Creating new series with UID: {}",
+        new_series_uid
+    );
+    println!(
+        "🔄 this_and_future: New series RRULE: {:?}",
+        new_series.rrule
+    );
+
     // Create the new series on CalDAV server
-    client.create_event(calendar_path, &new_series)
+    client
+        .create_event(calendar_path, &new_series)
         .await
         .map_err(|e| ApiError::Internal(format!("Failed to create new series: {}", e)))?;
-    
+
     println!("✅ this_and_future: Created new series successfully");
-    
+
     // Return the original event (with UNTIL added) - it will be updated by the main handler
     Ok((existing_event.clone(), 2)) // 2 operations: updated original + created new series
 }
@@ -725,91 +910,109 @@ async fn update_single_occurrence(
     // For RFC 5545 compliant single occurrence updates, we need to:
     // 1. Add EXDATE to the original series to exclude this occurrence
     // 2. Create a new exception event with RECURRENCE-ID pointing to the original occurrence
-    
+
     // First, add EXDATE to the original series
-    let occurrence_date = request.occurrence_date.as_ref()
-        .ok_or_else(|| ApiError::BadRequest("occurrence_date is required for single occurrence updates".to_string()))?;
-    
+    let occurrence_date = request.occurrence_date.as_ref().ok_or_else(|| {
+        ApiError::BadRequest(
+            "occurrence_date is required for single occurrence updates".to_string(),
+        )
+    })?;
+
     // Parse the occurrence date
-    let exception_date = chrono::NaiveDate::parse_from_str(occurrence_date, "%Y-%m-%d")
-        .map_err(|_| ApiError::BadRequest("Invalid occurrence date format. Expected YYYY-MM-DD".to_string()))?;
-    
+    let exception_date =
+        chrono::NaiveDate::parse_from_str(occurrence_date, "%Y-%m-%d").map_err(|_| {
+            ApiError::BadRequest("Invalid occurrence date format. Expected YYYY-MM-DD".to_string())
+        })?;
+
     // Create the EXDATE datetime using the original event's time
     let original_time = existing_event.dtstart.time();
     let exception_datetime = exception_date.and_time(original_time);
     let exception_utc = chrono::Utc.from_utc_datetime(&exception_datetime);
-    
+
     // Add the exception date to the original series
-    println!("📝 BEFORE adding EXDATE: existing_event.exdate = {:?}", existing_event.exdate);
+    println!(
+        "📝 BEFORE adding EXDATE: existing_event.exdate = {:?}",
+        existing_event.exdate
+    );
     existing_event.exdate.push(exception_utc);
-    println!("📝 AFTER adding EXDATE: existing_event.exdate = {:?}", existing_event.exdate);
-    println!("🚫 Added EXDATE for single occurrence modification: {}", exception_utc.format("%Y-%m-%d %H:%M:%S"));
-    
+    println!(
+        "📝 AFTER adding EXDATE: existing_event.exdate = {:?}",
+        existing_event.exdate
+    );
+    println!(
+        "🚫 Added EXDATE for single occurrence modification: {}",
+        exception_utc.format("%Y-%m-%d %H:%M:%S")
+    );
+
     // Create exception event by cloning the existing event to preserve all metadata
     let mut exception_event = existing_event.clone();
-    
+
     // Give the exception event a unique UID (required for CalDAV)
     exception_event.uid = format!("exception-{}", uuid::Uuid::new_v4());
-    
+
     // Update the modified properties from the request
     exception_event.dtstart = start_datetime;
     exception_event.dtend = Some(end_datetime);
-    exception_event.summary = if request.title.trim().is_empty() { 
-        existing_event.summary.clone()  // Keep original if empty
-    } else { 
-        Some(request.title.clone()) 
+    exception_event.summary = if request.title.trim().is_empty() {
+        existing_event.summary.clone() // Keep original if empty
+    } else {
+        Some(request.title.clone())
     };
-    exception_event.description = if request.description.trim().is_empty() { 
-        existing_event.description.clone()  // Keep original if empty
-    } else { 
-        Some(request.description.clone()) 
+    exception_event.description = if request.description.trim().is_empty() {
+        existing_event.description.clone() // Keep original if empty
+    } else {
+        Some(request.description.clone())
     };
-    exception_event.location = if request.location.trim().is_empty() { 
-        existing_event.location.clone()  // Keep original if empty
-    } else { 
-        Some(request.location.clone()) 
+    exception_event.location = if request.location.trim().is_empty() {
+        existing_event.location.clone() // Keep original if empty
+    } else {
+        Some(request.location.clone())
     };
-    
+
     exception_event.status = Some(match request.status.to_lowercase().as_str() {
         "tentative" => EventStatus::Tentative,
         "cancelled" => EventStatus::Cancelled,
         _ => EventStatus::Confirmed,
     });
-    
+
     exception_event.class = Some(match request.class.to_lowercase().as_str() {
         "private" => EventClass::Private,
         "confidential" => EventClass::Confidential,
         _ => EventClass::Public,
     });
-    
+
     exception_event.priority = request.priority;
-    
+
     // Update timestamps for the exception event
     let now = chrono::Utc::now();
     exception_event.dtstamp = now;
     exception_event.last_modified = Some(now);
     // Keep original created timestamp to preserve event history
-    
+
     // Set RECURRENCE-ID to point to the original occurrence
     // exception_event.recurrence_id = Some(exception_utc);
-    
+
     // Remove any recurrence rules from the exception (it's a single event)
     exception_event.rrule = None;
     exception_event.rdate.clear();
     exception_event.exdate.clear();
-    
-    // Set calendar path for the exception event 
+
+    // Set calendar path for the exception event
     exception_event.calendar_path = Some(calendar_path.to_string());
-    
-    println!("✨ Created exception event with RECURRENCE-ID: {}", exception_utc.format("%Y-%m-%d %H:%M:%S"));
-    
+
+    println!(
+        "✨ Created exception event with RECURRENCE-ID: {}",
+        exception_utc.format("%Y-%m-%d %H:%M:%S")
+    );
+
     // Create the exception event as a new event (original series will be updated by main handler)
-    client.create_event(calendar_path, &exception_event)
+    client
+        .create_event(calendar_path, &exception_event)
         .await
         .map_err(|e| ApiError::Internal(format!("Failed to create exception event: {}", e)))?;
-    
+
     println!("✅ Created exception event successfully");
-    
+
     // Return the original series (now with EXDATE) - main handler will update it on CalDAV
     Ok((existing_event.clone(), 1)) // 1 occurrence modified (via exception)
 }
@@ -820,10 +1023,11 @@ async fn delete_entire_series(
     request: &DeleteEventSeriesRequest,
 ) -> Result<u32, ApiError> {
     // Simply delete the entire event from the CalDAV server
-    client.delete_event(&request.calendar_path, &request.event_href)
+    client
+        .delete_event(&request.calendar_path, &request.event_href)
         .await
         .map_err(|e| ApiError::Internal(format!("Failed to delete event series: {}", e)))?;
-    
+
     println!("🗑️ Entire series deleted: {}", request.series_uid);
     Ok(1) // 1 series deleted (affects all occurrences)
 }
@@ -835,44 +1039,63 @@ async fn delete_this_and_future(
 ) -> Result<u32, ApiError> {
     // Fetch the existing event to modify its RRULE
     let event_uid = request.series_uid.clone();
-    let existing_event = client.fetch_event_by_uid(&request.calendar_path, &event_uid)
+    let existing_event = client
+        .fetch_event_by_uid(&request.calendar_path, &event_uid)
         .await
         .map_err(|e| ApiError::Internal(format!("Failed to fetch event for modification: {}", e)))?
-        .ok_or_else(|| ApiError::NotFound(format!("Event series with UID '{}' not found", event_uid)))?;
-    
+        .ok_or_else(|| {
+            ApiError::NotFound(format!("Event series with UID '{}' not found", event_uid))
+        })?;
+
     // If no occurrence_date is provided, delete the entire series
     let Some(occurrence_date) = &request.occurrence_date else {
         return delete_entire_series(client, request).await;
     };
-    
+
     // Parse occurrence date to set as UNTIL for the RRULE
-    let until_date = chrono::NaiveDate::parse_from_str(occurrence_date, "%Y-%m-%d")
-        .map_err(|_| ApiError::BadRequest("Invalid occurrence date format. Expected YYYY-MM-DD".to_string()))?;
-    
+    let until_date =
+        chrono::NaiveDate::parse_from_str(occurrence_date, "%Y-%m-%d").map_err(|_| {
+            ApiError::BadRequest("Invalid occurrence date format. Expected YYYY-MM-DD".to_string())
+        })?;
+
     // Set UNTIL to the day before the occurrence to exclude it and all future occurrences
-    let until_datetime = until_date.pred_opt()
-        .ok_or_else(|| ApiError::BadRequest("Cannot delete from the first possible date".to_string()))?
+    let until_datetime = until_date
+        .pred_opt()
+        .ok_or_else(|| {
+            ApiError::BadRequest("Cannot delete from the first possible date".to_string())
+        })?
         .and_hms_opt(23, 59, 59)
         .ok_or_else(|| ApiError::BadRequest("Invalid date calculation".to_string()))?;
     let utc_until = chrono::Utc.from_utc_datetime(&until_datetime);
-    
+
     // Modify the existing event's RRULE
     let mut updated_event = existing_event;
     if let Some(rrule) = &updated_event.rrule {
         // Remove existing UNTIL or COUNT if present and add new UNTIL
-        let parts: Vec<&str> = rrule.split(';').filter(|part| {
-            !part.starts_with("UNTIL=") && !part.starts_with("COUNT=")
-        }).collect();
-        
-        updated_event.rrule = Some(format!("{};UNTIL={}", parts.join(";"), utc_until.format("%Y%m%dT%H%M%SZ")));
+        let parts: Vec<&str> = rrule
+            .split(';')
+            .filter(|part| !part.starts_with("UNTIL=") && !part.starts_with("COUNT="))
+            .collect();
+
+        updated_event.rrule = Some(format!(
+            "{};UNTIL={}",
+            parts.join(";"),
+            utc_until.format("%Y%m%dT%H%M%SZ")
+        ));
     }
-    
+
     // Update the event on the CalDAV server
-    client.update_event(&request.calendar_path, &updated_event, &request.event_href)
+    client
+        .update_event(&request.calendar_path, &updated_event, &request.event_href)
         .await
-        .map_err(|e| ApiError::Internal(format!("Failed to update event series for deletion: {}", e)))?;
-    
-    println!("🗑️ Series modified with UNTIL for this_and_future deletion: {}", utc_until.format("%Y-%m-%d"));
+        .map_err(|e| {
+            ApiError::Internal(format!("Failed to update event series for deletion: {}", e))
+        })?;
+
+    println!(
+        "🗑️ Series modified with UNTIL for this_and_future deletion: {}",
+        utc_until.format("%Y-%m-%d")
+    );
     Ok(1) // 1 series modified
 }
 
@@ -883,35 +1106,51 @@ async fn delete_single_occurrence(
 ) -> Result<u32, ApiError> {
     // Fetch the existing event to add EXDATE
     let event_uid = request.series_uid.clone();
-    let existing_event = client.fetch_event_by_uid(&request.calendar_path, &event_uid)
+    let existing_event = client
+        .fetch_event_by_uid(&request.calendar_path, &event_uid)
         .await
         .map_err(|e| ApiError::Internal(format!("Failed to fetch event for modification: {}", e)))?
-        .ok_or_else(|| ApiError::NotFound(format!("Event series with UID '{}' not found", event_uid)))?;
-    
+        .ok_or_else(|| {
+            ApiError::NotFound(format!("Event series with UID '{}' not found", event_uid))
+        })?;
+
     // If no occurrence_date is provided, cannot delete single occurrence
     let Some(occurrence_date) = &request.occurrence_date else {
-        return Err(ApiError::BadRequest("occurrence_date is required for single occurrence deletion".to_string()));
+        return Err(ApiError::BadRequest(
+            "occurrence_date is required for single occurrence deletion".to_string(),
+        ));
     };
-    
+
     // Parse occurrence date
-    let exception_date = chrono::NaiveDate::parse_from_str(occurrence_date, "%Y-%m-%d")
-        .map_err(|_| ApiError::BadRequest("Invalid occurrence date format. Expected YYYY-MM-DD".to_string()))?;
-    
+    let exception_date =
+        chrono::NaiveDate::parse_from_str(occurrence_date, "%Y-%m-%d").map_err(|_| {
+            ApiError::BadRequest("Invalid occurrence date format. Expected YYYY-MM-DD".to_string())
+        })?;
+
     // Create the EXDATE datetime (use the same time as the original event)
     let original_time = existing_event.dtstart.time();
     let exception_datetime = exception_date.and_time(original_time);
     let exception_utc = chrono::Utc.from_utc_datetime(&exception_datetime);
-    
+
     // Add the exception date to the event's EXDATE list
     let mut updated_event = existing_event;
     updated_event.exdate.push(exception_utc);
-    
-    println!("🗑️ Added EXDATE for single occurrence deletion: {}", exception_utc.format("%Y%m%dT%H%M%SZ"));
-    
+
+    println!(
+        "🗑️ Added EXDATE for single occurrence deletion: {}",
+        exception_utc.format("%Y%m%dT%H%M%SZ")
+    );
+
     // Update the event on the CalDAV server
-    client.update_event(&request.calendar_path, &updated_event, &request.event_href)
+    client
+        .update_event(&request.calendar_path, &updated_event, &request.event_href)
         .await
-        .map_err(|e| ApiError::Internal(format!("Failed to update event series for single deletion: {}", e)))?;
-    
+        .map_err(|e| {
+            ApiError::Internal(format!(
+                "Failed to update event series for single deletion: {}",
+                e
+            ))
+        })?;
+
     Ok(1) // 1 occurrence excluded
 }
diff --git a/backend/src/lib.rs b/backend/src/lib.rs
index b69a5f5..a96e351 100644
--- a/backend/src/lib.rs
+++ b/backend/src/lib.rs
@@ -3,14 +3,14 @@ use axum::{
     routing::{get, post},
     Router,
 };
-use tower_http::cors::{CorsLayer, Any};
 use std::sync::Arc;
+use tower_http::cors::{Any, CorsLayer};
 
 pub mod auth;
-pub mod models;
-pub mod handlers;
 pub mod calendar;
 pub mod config;
+pub mod handlers;
+pub mod models;
 
 use auth::AuthService;
 
@@ -22,13 +22,13 @@ pub struct AppState {
 pub async fn run_server() -> Result<(), Box<dyn std::error::Error>> {
     // Initialize logging
     println!("🚀 Starting Calendar Backend Server");
-    
+
     // Create auth service
     let jwt_secret = std::env::var("JWT_SECRET")
         .unwrap_or_else(|_| "your-super-secret-jwt-key-change-in-production".to_string());
-    
+
     let auth_service = AuthService::new(jwt_secret);
-    
+
     let app_state = AppState { auth_service };
 
     // Build our application with routes
@@ -46,9 +46,18 @@ pub async fn run_server() -> Result<(), Box<dyn std::error::Error>> {
         .route("/api/calendar/events/delete", post(handlers::delete_event))
         .route("/api/calendar/events/:uid", get(handlers::refresh_event))
         // Event series-specific endpoints
-        .route("/api/calendar/events/series/create", post(handlers::create_event_series))
-        .route("/api/calendar/events/series/update", post(handlers::update_event_series))
-        .route("/api/calendar/events/series/delete", post(handlers::delete_event_series))
+        .route(
+            "/api/calendar/events/series/create",
+            post(handlers::create_event_series),
+        )
+        .route(
+            "/api/calendar/events/series/update",
+            post(handlers::update_event_series),
+        )
+        .route(
+            "/api/calendar/events/series/delete",
+            post(handlers::delete_event_series),
+        )
         .layer(
             CorsLayer::new()
                 .allow_origin(Any)
@@ -60,7 +69,7 @@ pub async fn run_server() -> Result<(), Box<dyn std::error::Error>> {
     // Start server
     let listener = tokio::net::TcpListener::bind("0.0.0.0:3000").await?;
     println!("📡 Server listening on http://0.0.0.0:3000");
-    
+
     axum::serve(listener, app).await?;
 
     Ok(())
@@ -76,4 +85,4 @@ async fn health_check() -> Json<serde_json::Value> {
         "service": "calendar-backend",
         "version": "0.1.0"
     }))
-}
\ No newline at end of file
+}
diff --git a/backend/src/main.rs b/backend/src/main.rs
index a3375fb..3fc1e66 100644
--- a/backend/src/main.rs
+++ b/backend/src/main.rs
@@ -4,4 +4,4 @@ use calendar_backend::*;
 #[tokio::main]
 async fn main() -> Result<(), Box<dyn std::error::Error>> {
     run_server().await
-}
\ No newline at end of file
+}
diff --git a/backend/src/models.rs b/backend/src/models.rs
index 853a352..4ce48fa 100644
--- a/backend/src/models.rs
+++ b/backend/src/models.rs
@@ -76,21 +76,21 @@ pub struct DeleteEventResponse {
 pub struct CreateEventRequest {
     pub title: String,
     pub description: String,
-    pub start_date: String,        // YYYY-MM-DD format
-    pub start_time: String,        // HH:MM format  
-    pub end_date: String,          // YYYY-MM-DD format
-    pub end_time: String,          // HH:MM format
+    pub start_date: String, // YYYY-MM-DD format
+    pub start_time: String, // HH:MM format
+    pub end_date: String,   // YYYY-MM-DD format
+    pub end_time: String,   // HH:MM format
     pub location: String,
     pub all_day: bool,
-    pub status: String,            // confirmed, tentative, cancelled
-    pub class: String,             // public, private, confidential
-    pub priority: Option<u8>,      // 0-9 priority level
-    pub organizer: String,         // organizer email
-    pub attendees: String,         // comma-separated attendee emails
-    pub categories: String,        // comma-separated categories
-    pub reminder: String,          // reminder type
-    pub recurrence: String,        // recurrence type
-    pub recurrence_days: Vec<bool>, // [Sun, Mon, Tue, Wed, Thu, Fri, Sat] for weekly recurrence
+    pub status: String,                // confirmed, tentative, cancelled
+    pub class: String,                 // public, private, confidential
+    pub priority: Option<u8>,          // 0-9 priority level
+    pub organizer: String,             // organizer email
+    pub attendees: String,             // comma-separated attendee emails
+    pub categories: String,            // comma-separated categories
+    pub reminder: String,              // reminder type
+    pub recurrence: String,            // recurrence type
+    pub recurrence_days: Vec<bool>,    // [Sun, Mon, Tue, Wed, Thu, Fri, Sat] for weekly recurrence
     pub calendar_path: Option<String>, // Optional - use first calendar if not specified
 }
 
@@ -103,24 +103,24 @@ pub struct CreateEventResponse {
 
 #[derive(Debug, Deserialize)]
 pub struct UpdateEventRequest {
-    pub uid: String,               // Event UID to identify which event to update
+    pub uid: String, // Event UID to identify which event to update
     pub title: String,
     pub description: String,
-    pub start_date: String,        // YYYY-MM-DD format
-    pub start_time: String,        // HH:MM format  
-    pub end_date: String,          // YYYY-MM-DD format
-    pub end_time: String,          // HH:MM format
+    pub start_date: String, // YYYY-MM-DD format
+    pub start_time: String, // HH:MM format
+    pub end_date: String,   // YYYY-MM-DD format
+    pub end_time: String,   // HH:MM format
     pub location: String,
     pub all_day: bool,
-    pub status: String,            // confirmed, tentative, cancelled
-    pub class: String,             // public, private, confidential
-    pub priority: Option<u8>,      // 0-9 priority level
-    pub organizer: String,         // organizer email
-    pub attendees: String,         // comma-separated attendee emails
-    pub categories: String,        // comma-separated categories
-    pub reminder: String,          // reminder type
-    pub recurrence: String,        // recurrence type
-    pub recurrence_days: Vec<bool>, // [Sun, Mon, Tue, Wed, Thu, Fri, Sat] for weekly recurrence
+    pub status: String,                // confirmed, tentative, cancelled
+    pub class: String,                 // public, private, confidential
+    pub priority: Option<u8>,          // 0-9 priority level
+    pub organizer: String,             // organizer email
+    pub attendees: String,             // comma-separated attendee emails
+    pub categories: String,            // comma-separated categories
+    pub reminder: String,              // reminder type
+    pub recurrence: String,            // recurrence type
+    pub recurrence_days: Vec<bool>,    // [Sun, Mon, Tue, Wed, Thu, Fri, Sat] for weekly recurrence
     pub calendar_path: Option<String>, // Optional - search all calendars if not specified
     pub update_action: Option<String>, // "update_series" for recurring events
     #[serde(skip_serializing_if = "Option::is_none")]
@@ -139,22 +139,22 @@ pub struct UpdateEventResponse {
 pub struct CreateEventSeriesRequest {
     pub title: String,
     pub description: String,
-    pub start_date: String,        // YYYY-MM-DD format
-    pub start_time: String,        // HH:MM format  
-    pub end_date: String,          // YYYY-MM-DD format
-    pub end_time: String,          // HH:MM format
+    pub start_date: String, // YYYY-MM-DD format
+    pub start_time: String, // HH:MM format
+    pub end_date: String,   // YYYY-MM-DD format
+    pub end_time: String,   // HH:MM format
     pub location: String,
     pub all_day: bool,
-    pub status: String,            // confirmed, tentative, cancelled
-    pub class: String,             // public, private, confidential
-    pub priority: Option<u8>,      // 0-9 priority level
-    pub organizer: String,         // organizer email
-    pub attendees: String,         // comma-separated attendee emails
-    pub categories: String,        // comma-separated categories
-    pub reminder: String,          // reminder type
-    
+    pub status: String,       // confirmed, tentative, cancelled
+    pub class: String,        // public, private, confidential
+    pub priority: Option<u8>, // 0-9 priority level
+    pub organizer: String,    // organizer email
+    pub attendees: String,    // comma-separated attendee emails
+    pub categories: String,   // comma-separated categories
+    pub reminder: String,     // reminder type
+
     // Series-specific fields
-    pub recurrence: String,        // recurrence type (daily, weekly, monthly, yearly)
+    pub recurrence: String, // recurrence type (daily, weekly, monthly, yearly)
     pub recurrence_days: Vec<bool>, // [Sun, Mon, Tue, Wed, Thu, Fri, Sat] for weekly recurrence
     pub recurrence_interval: Option<u32>, // Every N days/weeks/months/years
     pub recurrence_end_date: Option<String>, // When the series ends (YYYY-MM-DD)
@@ -173,33 +173,33 @@ pub struct CreateEventSeriesResponse {
 
 #[derive(Debug, Deserialize)]
 pub struct UpdateEventSeriesRequest {
-    pub series_uid: String,        // Series UID to identify which series to update
+    pub series_uid: String, // Series UID to identify which series to update
     pub title: String,
     pub description: String,
-    pub start_date: String,        // YYYY-MM-DD format
-    pub start_time: String,        // HH:MM format  
-    pub end_date: String,          // YYYY-MM-DD format
-    pub end_time: String,          // HH:MM format
+    pub start_date: String, // YYYY-MM-DD format
+    pub start_time: String, // HH:MM format
+    pub end_date: String,   // YYYY-MM-DD format
+    pub end_time: String,   // HH:MM format
     pub location: String,
     pub all_day: bool,
-    pub status: String,            // confirmed, tentative, cancelled
-    pub class: String,             // public, private, confidential
-    pub priority: Option<u8>,      // 0-9 priority level
-    pub organizer: String,         // organizer email
-    pub attendees: String,         // comma-separated attendee emails
-    pub categories: String,        // comma-separated categories
-    pub reminder: String,          // reminder type
-    
+    pub status: String,       // confirmed, tentative, cancelled
+    pub class: String,        // public, private, confidential
+    pub priority: Option<u8>, // 0-9 priority level
+    pub organizer: String,    // organizer email
+    pub attendees: String,    // comma-separated attendee emails
+    pub categories: String,   // comma-separated categories
+    pub reminder: String,     // reminder type
+
     // Series-specific fields
-    pub recurrence: String,        // recurrence type (daily, weekly, monthly, yearly)
+    pub recurrence: String, // recurrence type (daily, weekly, monthly, yearly)
     pub recurrence_days: Vec<bool>, // [Sun, Mon, Tue, Wed, Thu, Fri, Sat] for weekly recurrence
     pub recurrence_interval: Option<u32>, // Every N days/weeks/months/years
     pub recurrence_end_date: Option<String>, // When the series ends (YYYY-MM-DD)
     pub recurrence_count: Option<u32>, // Number of occurrences
     pub calendar_path: Option<String>, // Optional - search all calendars if not specified
-    
+
     // Update scope control
-    pub update_scope: String,      // "this_only", "this_and_future", "all_in_series"
+    pub update_scope: String, // "this_only", "this_and_future", "all_in_series"
     pub occurrence_date: Option<String>, // ISO date string for specific occurrence being updated
     pub changed_fields: Option<Vec<String>>, // List of field names that were changed (for optimization)
 }
@@ -214,12 +214,12 @@ pub struct UpdateEventSeriesResponse {
 
 #[derive(Debug, Deserialize)]
 pub struct DeleteEventSeriesRequest {
-    pub series_uid: String,        // Series UID to identify which series to delete
+    pub series_uid: String, // Series UID to identify which series to delete
     pub calendar_path: String,
     pub event_href: String,
-    
+
     // Delete scope control
-    pub delete_scope: String,      // "this_only", "this_and_future", "all_in_series"
+    pub delete_scope: String, // "this_only", "this_and_future", "all_in_series"
     pub occurrence_date: Option<String>, // ISO date string for specific occurrence being deleted
 }
 
@@ -274,4 +274,4 @@ impl std::fmt::Display for ApiError {
     }
 }
 
-impl std::error::Error for ApiError {}
\ No newline at end of file
+impl std::error::Error for ApiError {}
diff --git a/backend/tests/integration_tests.rs b/backend/tests/integration_tests.rs
index 44ad75f..1e27f2f 100644
--- a/backend/tests/integration_tests.rs
+++ b/backend/tests/integration_tests.rs
@@ -1,26 +1,26 @@
-use calendar_backend::AppState;
-use calendar_backend::auth::AuthService;
-use reqwest::Client;
-use serde_json::json;
-use std::time::Duration;
-use tokio::time::sleep;
 use axum::{
     response::Json,
     routing::{get, post},
     Router,
 };
-use tower_http::cors::{CorsLayer, Any};
+use calendar_backend::auth::AuthService;
+use calendar_backend::AppState;
+use reqwest::Client;
+use serde_json::json;
 use std::sync::Arc;
+use std::time::Duration;
+use tokio::time::sleep;
+use tower_http::cors::{Any, CorsLayer};
 
 /// Test utilities for integration testing
 mod test_utils {
     use super::*;
-    
+
     pub struct TestServer {
         pub base_url: String,
         pub client: Client,
     }
-    
+
     impl TestServer {
         pub async fn start() -> Self {
             // Create auth service
@@ -33,19 +33,55 @@ mod test_utils {
                 .route("/", get(root))
                 .route("/api/health", get(health_check))
                 .route("/api/auth/login", post(calendar_backend::handlers::login))
-                .route("/api/auth/verify", get(calendar_backend::handlers::verify_token))
-                .route("/api/user/info", get(calendar_backend::handlers::get_user_info))
-                .route("/api/calendar/create", post(calendar_backend::handlers::create_calendar))
-                .route("/api/calendar/delete", post(calendar_backend::handlers::delete_calendar))
-                .route("/api/calendar/events", get(calendar_backend::handlers::get_calendar_events))
-                .route("/api/calendar/events/create", post(calendar_backend::handlers::create_event))
-                .route("/api/calendar/events/update", post(calendar_backend::handlers::update_event))
-                .route("/api/calendar/events/delete", post(calendar_backend::handlers::delete_event))
-                .route("/api/calendar/events/:uid", get(calendar_backend::handlers::refresh_event))
+                .route(
+                    "/api/auth/verify",
+                    get(calendar_backend::handlers::verify_token),
+                )
+                .route(
+                    "/api/user/info",
+                    get(calendar_backend::handlers::get_user_info),
+                )
+                .route(
+                    "/api/calendar/create",
+                    post(calendar_backend::handlers::create_calendar),
+                )
+                .route(
+                    "/api/calendar/delete",
+                    post(calendar_backend::handlers::delete_calendar),
+                )
+                .route(
+                    "/api/calendar/events",
+                    get(calendar_backend::handlers::get_calendar_events),
+                )
+                .route(
+                    "/api/calendar/events/create",
+                    post(calendar_backend::handlers::create_event),
+                )
+                .route(
+                    "/api/calendar/events/update",
+                    post(calendar_backend::handlers::update_event),
+                )
+                .route(
+                    "/api/calendar/events/delete",
+                    post(calendar_backend::handlers::delete_event),
+                )
+                .route(
+                    "/api/calendar/events/:uid",
+                    get(calendar_backend::handlers::refresh_event),
+                )
                 // Event series-specific endpoints
-                .route("/api/calendar/events/series/create", post(calendar_backend::handlers::create_event_series))
-                .route("/api/calendar/events/series/update", post(calendar_backend::handlers::update_event_series))
-                .route("/api/calendar/events/series/delete", post(calendar_backend::handlers::delete_event_series))
+                .route(
+                    "/api/calendar/events/series/create",
+                    post(calendar_backend::handlers::create_event_series),
+                )
+                .route(
+                    "/api/calendar/events/series/update",
+                    post(calendar_backend::handlers::update_event_series),
+                )
+                .route(
+                    "/api/calendar/events/series/delete",
+                    post(calendar_backend::handlers::delete_event_series),
+                )
                 .layer(
                     CorsLayer::new()
                         .allow_origin(Any)
@@ -58,39 +94,47 @@ mod test_utils {
             let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
             let addr = listener.local_addr().unwrap();
             let base_url = format!("http://127.0.0.1:{}", addr.port());
-            
+
             tokio::spawn(async move {
                 axum::serve(listener, app).await.unwrap();
             });
-            
+
             // Wait for server to start
             sleep(Duration::from_millis(100)).await;
-            
+
             let client = Client::new();
             TestServer { base_url, client }
         }
-        
+
         pub async fn login(&self) -> String {
             let login_payload = json!({
                 "username": "test".to_string(),
                 "password": "test".to_string(),
                 "server_url": "https://example.com".to_string()
             });
-            
-            let response = self.client
+
+            let response = self
+                .client
                 .post(&format!("{}/api/auth/login", self.base_url))
                 .json(&login_payload)
                 .send()
                 .await
                 .expect("Failed to send login request");
-                
-            assert!(response.status().is_success(), "Login failed with status: {}", response.status());
-            
+
+            assert!(
+                response.status().is_success(),
+                "Login failed with status: {}",
+                response.status()
+            );
+
             let login_response: serde_json::Value = response.json().await.unwrap();
-            login_response["token"].as_str().expect("Login response should contain token").to_string()
+            login_response["token"]
+                .as_str()
+                .expect("Login response should contain token")
+                .to_string()
         }
     }
-    
+
     async fn root() -> &'static str {
         "Calendar Backend API v0.1.0"
     }
@@ -106,26 +150,27 @@ mod test_utils {
 
 #[cfg(test)]
 mod tests {
-    use super::*;
     use super::test_utils::*;
+    use super::*;
 
     /// Test the health endpoint
     #[tokio::test]
     async fn test_health_endpoint() {
         let server = TestServer::start().await;
-        
-        let response = server.client
+
+        let response = server
+            .client
             .get(&format!("{}/api/health", server.base_url))
             .send()
             .await
             .unwrap();
-            
+
         assert_eq!(response.status(), 200);
-        
+
         let health_response: serde_json::Value = response.json().await.unwrap();
         assert_eq!(health_response["status"], "healthy");
         assert_eq!(health_response["service"], "calendar-backend");
-        
+
         println!("✓ Health endpoint test passed");
     }
 
@@ -133,31 +178,42 @@ mod tests {
     #[tokio::test]
     async fn test_auth_login() {
         let server = TestServer::start().await;
-        
+
         // Use test credentials
         let username = "test".to_string();
-        let password = "test".to_string(); 
+        let password = "test".to_string();
         let server_url = "https://example.com".to_string();
-        
+
         let login_payload = json!({
             "username": username,
             "password": password,
             "server_url": server_url
         });
-        
-        let response = server.client
+
+        let response = server
+            .client
             .post(&format!("{}/api/auth/login", server.base_url))
             .json(&login_payload)
             .send()
             .await
             .unwrap();
-            
-        assert!(response.status().is_success(), "Login failed with status: {}", response.status());
-        
+
+        assert!(
+            response.status().is_success(),
+            "Login failed with status: {}",
+            response.status()
+        );
+
         let login_response: serde_json::Value = response.json().await.unwrap();
-        assert!(login_response["token"].is_string(), "Login response should contain a token");
-        assert!(login_response["username"].is_string(), "Login response should contain username");
-        
+        assert!(
+            login_response["token"].is_string(),
+            "Login response should contain a token"
+        );
+        assert!(
+            login_response["username"].is_string(),
+            "Login response should contain username"
+        );
+
         println!("✓ Authentication login test passed");
     }
 
@@ -165,52 +221,57 @@ mod tests {
     #[tokio::test]
     async fn test_auth_verify() {
         let server = TestServer::start().await;
-        
+
         // First login to get a token
         let token = server.login().await;
-        
-        let response = server.client
+
+        let response = server
+            .client
             .get(&format!("{}/api/auth/verify", server.base_url))
             .header("Authorization", format!("Bearer {}", token))
             .send()
             .await
             .unwrap();
-            
+
         assert_eq!(response.status(), 200);
-        
+
         let verify_response: serde_json::Value = response.json().await.unwrap();
         assert!(verify_response["valid"].as_bool().unwrap_or(false));
-        
+
         println!("✓ Authentication verify test passed");
     }
 
     /// Test user info endpoint
-    #[tokio::test] 
+    #[tokio::test]
     async fn test_user_info() {
         let server = TestServer::start().await;
-        
+
         // First login to get a token
         let token = server.login().await;
-        
+
         // Load password from env for CalDAV requests
         dotenvy::dotenv().ok();
         let password = "test".to_string();
-        
-        let response = server.client
+
+        let response = server
+            .client
             .get(&format!("{}/api/user/info", server.base_url))
             .header("Authorization", format!("Bearer {}", token))
             .header("X-CalDAV-Password", password)
             .send()
             .await
             .unwrap();
-            
+
         // Note: This might fail if CalDAV server discovery fails, which can happen
         if response.status().is_success() {
             let user_info: serde_json::Value = response.json().await.unwrap();
             assert!(user_info["username"].is_string());
             println!("✓ User info test passed");
         } else {
-            println!("⚠ User info test skipped (CalDAV server issues): {}", response.status());
+            println!(
+                "⚠ User info test skipped (CalDAV server issues): {}",
+                response.status()
+            );
         }
     }
 
@@ -218,48 +279,59 @@ mod tests {
     #[tokio::test]
     async fn test_get_calendar_events() {
         let server = TestServer::start().await;
-        
+
         // First login to get a token
         let token = server.login().await;
-        
-        // Load password from env for CalDAV requests  
+
+        // Load password from env for CalDAV requests
         dotenvy::dotenv().ok();
         let password = "test".to_string();
-        
-        let response = server.client
-            .get(&format!("{}/api/calendar/events?year=2024&month=12", server.base_url))
+
+        let response = server
+            .client
+            .get(&format!(
+                "{}/api/calendar/events?year=2024&month=12",
+                server.base_url
+            ))
             .header("Authorization", format!("Bearer {}", token))
             .header("X-CalDAV-Password", password)
             .send()
             .await
             .unwrap();
-            
-        assert!(response.status().is_success(), "Get events failed with status: {}", response.status());
-        
+
+        assert!(
+            response.status().is_success(),
+            "Get events failed with status: {}",
+            response.status()
+        );
+
         let events: serde_json::Value = response.json().await.unwrap();
         assert!(events.is_array());
-        
-        println!("✓ Get calendar events test passed (found {} events)", events.as_array().unwrap().len());
+
+        println!(
+            "✓ Get calendar events test passed (found {} events)",
+            events.as_array().unwrap().len()
+        );
     }
 
     /// Test event creation endpoint
     #[tokio::test]
     async fn test_create_event() {
         let server = TestServer::start().await;
-        
+
         // First login to get a token
         let token = server.login().await;
-        
+
         // Load password from env for CalDAV requests
-        dotenvy::dotenv().ok(); 
+        dotenvy::dotenv().ok();
         let password = "test".to_string();
-        
+
         let create_payload = json!({
             "title": "Integration Test Event",
             "description": "Created by integration test",
             "start_date": "2024-12-25",
             "start_time": "10:00",
-            "end_date": "2024-12-25", 
+            "end_date": "2024-12-25",
             "end_time": "11:00",
             "location": "Test Location",
             "all_day": false,
@@ -273,8 +345,9 @@ mod tests {
             "recurrence": "none",
             "recurrence_days": [false, false, false, false, false, false, false]
         });
-        
-        let response = server.client
+
+        let response = server
+            .client
             .post(&format!("{}/api/calendar/events/create", server.base_url))
             .header("Authorization", format!("Bearer {}", token))
             .header("X-CalDAV-Password", password)
@@ -282,10 +355,10 @@ mod tests {
             .send()
             .await
             .unwrap();
-            
+
         let status = response.status();
         println!("Create event response status: {}", status);
-        
+
         // Note: This might fail if CalDAV server is not accessible, which is expected in CI
         if status.is_success() {
             let create_response: serde_json::Value = response.json().await.unwrap();
@@ -300,47 +373,58 @@ mod tests {
     #[tokio::test]
     async fn test_refresh_event() {
         let server = TestServer::start().await;
-        
+
         // First login to get a token
         let token = server.login().await;
-        
+
         // Load password from env for CalDAV requests
         dotenvy::dotenv().ok();
         let password = "test".to_string();
-        
+
         // Use a dummy UID for testing - this will likely return 404 but we're testing the endpoint structure
         let test_uid = "test-event-uid";
-        
-        let response = server.client
-            .get(&format!("{}/api/calendar/events/{}", server.base_url, test_uid))
+
+        let response = server
+            .client
+            .get(&format!(
+                "{}/api/calendar/events/{}",
+                server.base_url, test_uid
+            ))
             .header("Authorization", format!("Bearer {}", token))
             .header("X-CalDAV-Password", password)
             .send()
             .await
             .unwrap();
-            
+
         // We expect either 200 (if event exists) or 404 (if not found) - both are valid responses
-        assert!(response.status() == 200 || response.status() == 404, 
-               "Refresh event failed with unexpected status: {}", response.status());
-               
+        assert!(
+            response.status() == 200 || response.status() == 404,
+            "Refresh event failed with unexpected status: {}",
+            response.status()
+        );
+
         println!("✓ Refresh event endpoint test passed");
     }
-    
+
     /// Test invalid authentication
     #[tokio::test]
     async fn test_invalid_auth() {
         let server = TestServer::start().await;
-        
-        let response = server.client
+
+        let response = server
+            .client
             .get(&format!("{}/api/user/info", server.base_url))
             .header("Authorization", "Bearer invalid-token")
             .send()
             .await
             .unwrap();
-            
+
         // Accept both 400 and 401 as valid responses for invalid tokens
-        assert!(response.status() == 401 || response.status() == 400, 
-               "Expected 401 or 400 for invalid token, got {}", response.status());
+        assert!(
+            response.status() == 401 || response.status() == 400,
+            "Expected 401 or 400 for invalid token, got {}",
+            response.status()
+        );
         println!("✓ Invalid authentication test passed");
     }
 
@@ -348,13 +432,14 @@ mod tests {
     #[tokio::test]
     async fn test_missing_auth() {
         let server = TestServer::start().await;
-        
-        let response = server.client
+
+        let response = server
+            .client
             .get(&format!("{}/api/user/info", server.base_url))
             .send()
             .await
             .unwrap();
-            
+
         assert_eq!(response.status(), 401);
         println!("✓ Missing authentication test passed");
     }
@@ -365,20 +450,20 @@ mod tests {
     #[tokio::test]
     async fn test_create_event_series() {
         let server = TestServer::start().await;
-        
+
         // First login to get a token
         let token = server.login().await;
-        
+
         // Load password from env for CalDAV requests
         dotenvy::dotenv().ok();
         let password = "test".to_string();
-        
+
         let create_payload = json!({
             "title": "Integration Test Series",
             "description": "Created by integration test for series",
             "start_date": "2024-12-25",
             "start_time": "10:00",
-            "end_date": "2024-12-25", 
+            "end_date": "2024-12-25",
             "end_time": "11:00",
             "location": "Test Series Location",
             "all_day": false,
@@ -395,19 +480,23 @@ mod tests {
             "recurrence_count": 4,
             "calendar_path": "/calendars/test/default/" // Provide explicit path to bypass discovery
         });
-        
-        let response = server.client
-            .post(&format!("{}/api/calendar/events/series/create", server.base_url))
+
+        let response = server
+            .client
+            .post(&format!(
+                "{}/api/calendar/events/series/create",
+                server.base_url
+            ))
             .header("Authorization", format!("Bearer {}", token))
             .header("X-CalDAV-Password", password)
             .json(&create_payload)
             .send()
             .await
             .unwrap();
-            
+
         let status = response.status();
         println!("Create series response status: {}", status);
-        
+
         // Note: This might fail if CalDAV server is not accessible, which is expected in CI
         if status.is_success() {
             let create_response: serde_json::Value = response.json().await.unwrap();
@@ -420,24 +509,24 @@ mod tests {
     }
 
     /// Test event series update endpoint
-    #[tokio::test] 
+    #[tokio::test]
     async fn test_update_event_series() {
         let server = TestServer::start().await;
-        
+
         // First login to get a token
         let token = server.login().await;
-        
+
         // Load password from env for CalDAV requests
         dotenvy::dotenv().ok();
         let password = "test".to_string();
-        
+
         let update_payload = json!({
             "series_uid": "test-series-uid",
             "title": "Updated Series Title",
             "description": "Updated by integration test",
             "start_date": "2024-12-26",
             "start_time": "14:00",
-            "end_date": "2024-12-26", 
+            "end_date": "2024-12-26",
             "end_time": "15:00",
             "location": "Updated Location",
             "all_day": false,
@@ -455,27 +544,36 @@ mod tests {
             "update_scope": "all_in_series",
             "calendar_path": "/calendars/test/default/" // Provide explicit path to bypass discovery
         });
-        
-        let response = server.client
-            .post(&format!("{}/api/calendar/events/series/update", server.base_url))
+
+        let response = server
+            .client
+            .post(&format!(
+                "{}/api/calendar/events/series/update",
+                server.base_url
+            ))
             .header("Authorization", format!("Bearer {}", token))
             .header("X-CalDAV-Password", password)
             .json(&update_payload)
             .send()
             .await
             .unwrap();
-            
+
         let status = response.status();
         println!("Update series response status: {}", status);
-        
+
         // Note: This might fail if CalDAV server is not accessible or event doesn't exist, which is expected in CI
         if status.is_success() {
             let update_response: serde_json::Value = response.json().await.unwrap();
             assert!(update_response["success"].as_bool().unwrap_or(false));
-            assert_eq!(update_response["series_uid"].as_str().unwrap(), "test-series-uid");
+            assert_eq!(
+                update_response["series_uid"].as_str().unwrap(),
+                "test-series-uid"
+            );
             println!("✓ Update event series test passed");
         } else if status == 404 {
-            println!("⚠ Update event series test skipped (event not found - expected for test data)");
+            println!(
+                "⚠ Update event series test skipped (event not found - expected for test data)"
+            );
         } else {
             println!("⚠ Update event series test skipped (CalDAV server not accessible)");
         }
@@ -485,40 +583,46 @@ mod tests {
     #[tokio::test]
     async fn test_delete_event_series() {
         let server = TestServer::start().await;
-        
-        // First login to get a token  
+
+        // First login to get a token
         let token = server.login().await;
-        
+
         // Load password from env for CalDAV requests
         dotenvy::dotenv().ok();
         let password = "test".to_string();
-        
+
         let delete_payload = json!({
             "series_uid": "test-series-to-delete",
             "calendar_path": "/calendars/test/default/",
             "event_href": "test-series.ics",
             "delete_scope": "all_in_series"
         });
-        
-        let response = server.client
-            .post(&format!("{}/api/calendar/events/series/delete", server.base_url))
+
+        let response = server
+            .client
+            .post(&format!(
+                "{}/api/calendar/events/series/delete",
+                server.base_url
+            ))
             .header("Authorization", format!("Bearer {}", token))
             .header("X-CalDAV-Password", password)
             .json(&delete_payload)
             .send()
             .await
             .unwrap();
-            
+
         let status = response.status();
         println!("Delete series response status: {}", status);
-        
+
         // Note: This might fail if CalDAV server is not accessible or event doesn't exist, which is expected in CI
         if status.is_success() {
             let delete_response: serde_json::Value = response.json().await.unwrap();
             assert!(delete_response["success"].as_bool().unwrap_or(false));
             println!("✓ Delete event series test passed");
         } else if status == 404 {
-            println!("⚠ Delete event series test skipped (event not found - expected for test data)");
+            println!(
+                "⚠ Delete event series test skipped (event not found - expected for test data)"
+            );
         } else {
             println!("⚠ Delete event series test skipped (CalDAV server not accessible)");
         }
@@ -528,17 +632,17 @@ mod tests {
     #[tokio::test]
     async fn test_invalid_update_scope() {
         let server = TestServer::start().await;
-        
+
         // First login to get a token
         let token = server.login().await;
-        
+
         let invalid_payload = json!({
             "series_uid": "test-series-uid",
             "title": "Test Title",
             "description": "Test",
             "start_date": "2024-12-25",
             "start_time": "10:00",
-            "end_date": "2024-12-25", 
+            "end_date": "2024-12-25",
             "end_time": "11:00",
             "location": "Test",
             "all_day": false,
@@ -552,16 +656,24 @@ mod tests {
             "recurrence_days": [false, false, false, false, false, false, false],
             "update_scope": "invalid_scope" // This should cause a 400 error
         });
-        
-        let response = server.client
-            .post(&format!("{}/api/calendar/events/series/update", server.base_url))
+
+        let response = server
+            .client
+            .post(&format!(
+                "{}/api/calendar/events/series/update",
+                server.base_url
+            ))
             .header("Authorization", format!("Bearer {}", token))
             .json(&invalid_payload)
             .send()
             .await
             .unwrap();
-            
-        assert_eq!(response.status(), 400, "Expected 400 for invalid update scope");
+
+        assert_eq!(
+            response.status(),
+            400,
+            "Expected 400 for invalid update scope"
+        );
         println!("✓ Invalid update scope test passed");
     }
 
@@ -569,16 +681,16 @@ mod tests {
     #[tokio::test]
     async fn test_non_recurring_series_rejection() {
         let server = TestServer::start().await;
-        
+
         // First login to get a token
         let token = server.login().await;
-        
+
         let non_recurring_payload = json!({
             "title": "Non-recurring Event",
             "description": "This should be rejected",
             "start_date": "2024-12-25",
             "start_time": "10:00",
-            "end_date": "2024-12-25", 
+            "end_date": "2024-12-25",
             "end_time": "11:00",
             "location": "Test",
             "all_day": false,
@@ -591,16 +703,24 @@ mod tests {
             "recurrence": "none", // This should cause rejection
             "recurrence_days": [false, false, false, false, false, false, false]
         });
-        
-        let response = server.client
-            .post(&format!("{}/api/calendar/events/series/create", server.base_url))
+
+        let response = server
+            .client
+            .post(&format!(
+                "{}/api/calendar/events/series/create",
+                server.base_url
+            ))
             .header("Authorization", format!("Bearer {}", token))
             .json(&non_recurring_payload)
             .send()
             .await
             .unwrap();
-            
-        assert_eq!(response.status(), 400, "Expected 400 for non-recurring event in series endpoint");
+
+        assert_eq!(
+            response.status(),
+            400,
+            "Expected 400 for non-recurring event in series endpoint"
+        );
         println!("✓ Non-recurring series rejection test passed");
     }
-}
\ No newline at end of file
+}
diff --git a/calendar-models/src/common.rs b/calendar-models/src/common.rs
index c6d5940..81643ce 100644
--- a/calendar-models/src/common.rs
+++ b/calendar-models/src/common.rs
@@ -1,6 +1,6 @@
 //! Common types and enums used across calendar components
 
-use chrono::{DateTime, Utc, Duration};
+use chrono::{DateTime, Duration, Utc};
 use serde::{Deserialize, Serialize};
 
 // ==================== ENUMS AND COMMON TYPES ====================
@@ -22,7 +22,7 @@ pub enum EventClass {
 #[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
 pub enum TimeTransparency {
     Opaque,      // OPAQUE - time is not available
-    Transparent, // TRANSPARENT - time is available  
+    Transparent, // TRANSPARENT - time is available
 }
 
 #[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
@@ -64,11 +64,11 @@ pub enum AlarmAction {
 
 #[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
 pub struct CalendarUser {
-    pub cal_address: String,                    // Calendar user address (usually email)
-    pub common_name: Option<String>,            // CN parameter - display name
-    pub dir_entry_ref: Option<String>,          // DIR parameter - directory entry
-    pub sent_by: Option<String>,                // SENT-BY parameter
-    pub language: Option<String>,               // LANGUAGE parameter
+    pub cal_address: String,           // Calendar user address (usually email)
+    pub common_name: Option<String>,   // CN parameter - display name
+    pub dir_entry_ref: Option<String>, // DIR parameter - directory entry
+    pub sent_by: Option<String>,       // SENT-BY parameter
+    pub language: Option<String>,      // LANGUAGE parameter
 }
 
 #[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
@@ -78,130 +78,130 @@ pub struct Attendee {
     pub role: Option<AttendeeRole>,             // ROLE parameter
     pub part_stat: Option<ParticipationStatus>, // PARTSTAT parameter
     pub rsvp: Option<bool>,                     // RSVP parameter
-    pub cu_type: Option<String>,                // CUTYPE parameter (INDIVIDUAL, GROUP, RESOURCE, ROOM, UNKNOWN)
-    pub member: Vec<String>,                    // MEMBER parameter
-    pub delegated_to: Vec<String>,              // DELEGATED-TO parameter  
-    pub delegated_from: Vec<String>,            // DELEGATED-FROM parameter
-    pub sent_by: Option<String>,                // SENT-BY parameter
-    pub dir_entry_ref: Option<String>,          // DIR parameter
-    pub language: Option<String>,               // LANGUAGE parameter
+    pub cu_type: Option<String>, // CUTYPE parameter (INDIVIDUAL, GROUP, RESOURCE, ROOM, UNKNOWN)
+    pub member: Vec<String>,     // MEMBER parameter
+    pub delegated_to: Vec<String>, // DELEGATED-TO parameter
+    pub delegated_from: Vec<String>, // DELEGATED-FROM parameter
+    pub sent_by: Option<String>, // SENT-BY parameter
+    pub dir_entry_ref: Option<String>, // DIR parameter
+    pub language: Option<String>, // LANGUAGE parameter
 }
 
 #[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
 pub struct VAlarm {
-    pub action: AlarmAction,                    // Action (ACTION) - REQUIRED
-    pub trigger: AlarmTrigger,                  // Trigger (TRIGGER) - REQUIRED
-    pub duration: Option<Duration>,             // Duration (DURATION)
-    pub repeat: Option<u32>,                    // Repeat count (REPEAT)
-    pub description: Option<String>,            // Description for DISPLAY/EMAIL
-    pub summary: Option<String>,                // Summary for EMAIL
-    pub attendees: Vec<Attendee>,               // Attendees for EMAIL
-    pub attach: Vec<Attachment>,                // Attachments for AUDIO/EMAIL
+    pub action: AlarmAction,         // Action (ACTION) - REQUIRED
+    pub trigger: AlarmTrigger,       // Trigger (TRIGGER) - REQUIRED
+    pub duration: Option<Duration>,  // Duration (DURATION)
+    pub repeat: Option<u32>,         // Repeat count (REPEAT)
+    pub description: Option<String>, // Description for DISPLAY/EMAIL
+    pub summary: Option<String>,     // Summary for EMAIL
+    pub attendees: Vec<Attendee>,    // Attendees for EMAIL
+    pub attach: Vec<Attachment>,     // Attachments for AUDIO/EMAIL
 }
 
 #[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
 pub enum AlarmTrigger {
-    DateTime(DateTime<Utc>),                    // Absolute trigger time
-    Duration(Duration),                         // Duration relative to start/end
+    DateTime(DateTime<Utc>), // Absolute trigger time
+    Duration(Duration),      // Duration relative to start/end
 }
 
 #[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
 pub struct Attachment {
-    pub format_type: Option<String>,            // FMTTYPE parameter (MIME type)
-    pub encoding: Option<String>,               // ENCODING parameter
-    pub value: Option<String>,                  // VALUE parameter (BINARY or URI)
-    pub uri: Option<String>,                    // URI reference
-    pub binary_data: Option<Vec<u8>>,           // Binary data (when ENCODING=BASE64)
+    pub format_type: Option<String>,  // FMTTYPE parameter (MIME type)
+    pub encoding: Option<String>,     // ENCODING parameter
+    pub value: Option<String>,        // VALUE parameter (BINARY or URI)
+    pub uri: Option<String>,          // URI reference
+    pub binary_data: Option<Vec<u8>>, // Binary data (when ENCODING=BASE64)
 }
 
 #[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
 pub struct GeographicPosition {
-    pub latitude: f64,                          // Latitude in decimal degrees
-    pub longitude: f64,                         // Longitude in decimal degrees
+    pub latitude: f64,  // Latitude in decimal degrees
+    pub longitude: f64, // Longitude in decimal degrees
 }
 
 #[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
 pub struct VTimeZone {
-    pub tzid: String,                           // Time zone ID (TZID) - REQUIRED
-    pub last_modified: Option<DateTime<Utc>>,   // Last modified (LAST-MODIFIED)
-    pub tzurl: Option<String>,                  // Time zone URL (TZURL)
+    pub tzid: String,                                // Time zone ID (TZID) - REQUIRED
+    pub last_modified: Option<DateTime<Utc>>,        // Last modified (LAST-MODIFIED)
+    pub tzurl: Option<String>,                       // Time zone URL (TZURL)
     pub standard_components: Vec<TimeZoneComponent>, // STANDARD components
     pub daylight_components: Vec<TimeZoneComponent>, // DAYLIGHT components
 }
 
 #[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
 pub struct TimeZoneComponent {
-    pub dtstart: DateTime<Utc>,                 // Start of this time zone definition
-    pub tzoffset_to: String,                    // UTC offset for this component
-    pub tzoffset_from: String,                  // UTC offset before this component  
-    pub rrule: Option<String>,                  // Recurrence rule
-    pub rdate: Vec<DateTime<Utc>>,              // Recurrence dates
-    pub tzname: Vec<String>,                    // Time zone names
-    pub comment: Vec<String>,                   // Comments
+    pub dtstart: DateTime<Utc>,    // Start of this time zone definition
+    pub tzoffset_to: String,       // UTC offset for this component
+    pub tzoffset_from: String,     // UTC offset before this component
+    pub rrule: Option<String>,     // Recurrence rule
+    pub rdate: Vec<DateTime<Utc>>, // Recurrence dates
+    pub tzname: Vec<String>,       // Time zone names
+    pub comment: Vec<String>,      // Comments
 }
 
 #[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
 pub struct VJournal {
     // Required properties
-    pub dtstamp: DateTime<Utc>,                 // Date-time stamp (DTSTAMP) - REQUIRED
-    pub uid: String,                            // Unique identifier (UID) - REQUIRED
-    
+    pub dtstamp: DateTime<Utc>, // Date-time stamp (DTSTAMP) - REQUIRED
+    pub uid: String,            // Unique identifier (UID) - REQUIRED
+
     // Optional properties
-    pub dtstart: Option<DateTime<Utc>>,         // Start date-time (DTSTART)
-    pub summary: Option<String>,                // Summary/title (SUMMARY) 
-    pub description: Option<String>,            // Description (DESCRIPTION)
-    
+    pub dtstart: Option<DateTime<Utc>>, // Start date-time (DTSTART)
+    pub summary: Option<String>,        // Summary/title (SUMMARY)
+    pub description: Option<String>,    // Description (DESCRIPTION)
+
     // Classification and status
-    pub class: Option<EventClass>,              // Classification (CLASS)
-    pub status: Option<String>,                 // Status (STATUS)
-    
+    pub class: Option<EventClass>, // Classification (CLASS)
+    pub status: Option<String>,    // Status (STATUS)
+
     // People and organization
-    pub organizer: Option<CalendarUser>,        // Organizer (ORGANIZER)
-    pub attendees: Vec<Attendee>,               // Attendees (ATTENDEE)
-    
+    pub organizer: Option<CalendarUser>, // Organizer (ORGANIZER)
+    pub attendees: Vec<Attendee>,        // Attendees (ATTENDEE)
+
     // Categorization
-    pub categories: Vec<String>,                // Categories (CATEGORIES)
-    
+    pub categories: Vec<String>, // Categories (CATEGORIES)
+
     // Versioning and modification
-    pub sequence: Option<u32>,                  // Sequence number (SEQUENCE)
-    pub created: Option<DateTime<Utc>>,         // Creation time (CREATED)
-    pub last_modified: Option<DateTime<Utc>>,   // Last modified (LAST-MODIFIED)
-    
+    pub sequence: Option<u32>,                // Sequence number (SEQUENCE)
+    pub created: Option<DateTime<Utc>>,       // Creation time (CREATED)
+    pub last_modified: Option<DateTime<Utc>>, // Last modified (LAST-MODIFIED)
+
     // Recurrence
-    pub rrule: Option<String>,                  // Recurrence rule (RRULE)
-    pub rdate: Vec<DateTime<Utc>>,              // Recurrence dates (RDATE)
-    pub exdate: Vec<DateTime<Utc>>,             // Exception dates (EXDATE)
-    pub recurrence_id: Option<DateTime<Utc>>,   // Recurrence ID (RECURRENCE-ID)
-    
+    pub rrule: Option<String>,                // Recurrence rule (RRULE)
+    pub rdate: Vec<DateTime<Utc>>,            // Recurrence dates (RDATE)
+    pub exdate: Vec<DateTime<Utc>>,           // Exception dates (EXDATE)
+    pub recurrence_id: Option<DateTime<Utc>>, // Recurrence ID (RECURRENCE-ID)
+
     // Attachments
-    pub attachments: Vec<Attachment>,           // Attachments (ATTACH)
+    pub attachments: Vec<Attachment>, // Attachments (ATTACH)
 }
 
 #[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
 pub struct VFreeBusy {
     // Required properties
-    pub dtstamp: DateTime<Utc>,                 // Date-time stamp (DTSTAMP) - REQUIRED
-    pub uid: String,                            // Unique identifier (UID) - REQUIRED
-    
+    pub dtstamp: DateTime<Utc>, // Date-time stamp (DTSTAMP) - REQUIRED
+    pub uid: String,            // Unique identifier (UID) - REQUIRED
+
     // Optional date-time properties
-    pub dtstart: Option<DateTime<Utc>>,         // Start date-time (DTSTART)
-    pub dtend: Option<DateTime<Utc>>,           // End date-time (DTEND)
-    
+    pub dtstart: Option<DateTime<Utc>>, // Start date-time (DTSTART)
+    pub dtend: Option<DateTime<Utc>>,   // End date-time (DTEND)
+
     // People
-    pub organizer: Option<CalendarUser>,        // Organizer (ORGANIZER)
-    pub attendees: Vec<Attendee>,               // Attendees (ATTENDEE)
-    
+    pub organizer: Option<CalendarUser>, // Organizer (ORGANIZER)
+    pub attendees: Vec<Attendee>,        // Attendees (ATTENDEE)
+
     // Free/busy time
-    pub freebusy: Vec<FreeBusyTime>,            // Free/busy time periods
-    pub url: Option<String>,                    // URL (URL)
-    pub comment: Vec<String>,                   // Comments (COMMENT)
-    pub contact: Option<String>,                // Contact information (CONTACT)
+    pub freebusy: Vec<FreeBusyTime>, // Free/busy time periods
+    pub url: Option<String>,         // URL (URL)
+    pub comment: Vec<String>,        // Comments (COMMENT)
+    pub contact: Option<String>,     // Contact information (CONTACT)
 }
 
 #[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
 pub struct FreeBusyTime {
-    pub fb_type: FreeBusyType,                  // Free/busy type
-    pub periods: Vec<Period>,                   // Time periods
+    pub fb_type: FreeBusyType, // Free/busy type
+    pub periods: Vec<Period>,  // Time periods
 }
 
 #[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
@@ -214,7 +214,7 @@ pub enum FreeBusyType {
 
 #[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
 pub struct Period {
-    pub start: DateTime<Utc>,                   // Period start
-    pub end: Option<DateTime<Utc>>,             // Period end
-    pub duration: Option<Duration>,             // Period duration (alternative to end)
-}
\ No newline at end of file
+    pub start: DateTime<Utc>,       // Period start
+    pub end: Option<DateTime<Utc>>, // Period end
+    pub duration: Option<Duration>, // Period duration (alternative to end)
+}
diff --git a/calendar-models/src/lib.rs b/calendar-models/src/lib.rs
index e8c9712..8e71325 100644
--- a/calendar-models/src/lib.rs
+++ b/calendar-models/src/lib.rs
@@ -1,10 +1,10 @@
 //! RFC 5545 Compliant Calendar Models
-//! 
+//!
 //! This crate provides shared data structures for calendar applications
 //! that comply with RFC 5545 (iCalendar) specification.
 
-pub mod vevent;
 pub mod common;
+pub mod vevent;
 
+pub use common::*;
 pub use vevent::*;
-pub use common::*;
\ No newline at end of file
diff --git a/calendar-models/src/vevent.rs b/calendar-models/src/vevent.rs
index 6f50df2..48930c4 100644
--- a/calendar-models/src/vevent.rs
+++ b/calendar-models/src/vevent.rs
@@ -1,66 +1,66 @@
 //! VEvent - RFC 5545 compliant calendar event structure
 
-use chrono::{DateTime, Utc, Duration};
-use serde::{Deserialize, Serialize};
 use crate::common::*;
+use chrono::{DateTime, Duration, Utc};
+use serde::{Deserialize, Serialize};
 
 // ==================== VEVENT COMPONENT ====================
 
 #[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
 pub struct VEvent {
     // Required properties
-    pub dtstamp: DateTime<Utc>,                 // Date-time stamp (DTSTAMP) - REQUIRED
-    pub uid: String,                            // Unique identifier (UID) - REQUIRED
-    pub dtstart: DateTime<Utc>,                 // Start date-time (DTSTART) - REQUIRED
-    
+    pub dtstamp: DateTime<Utc>, // Date-time stamp (DTSTAMP) - REQUIRED
+    pub uid: String,            // Unique identifier (UID) - REQUIRED
+    pub dtstart: DateTime<Utc>, // Start date-time (DTSTART) - REQUIRED
+
     // Optional properties (commonly used)
-    pub dtend: Option<DateTime<Utc>>,           // End date-time (DTEND)
-    pub duration: Option<Duration>,             // Duration (DURATION) - alternative to DTEND
-    pub summary: Option<String>,                // Summary/title (SUMMARY)
-    pub description: Option<String>,            // Description (DESCRIPTION)
-    pub location: Option<String>,               // Location (LOCATION)
-    
+    pub dtend: Option<DateTime<Utc>>, // End date-time (DTEND)
+    pub duration: Option<Duration>,   // Duration (DURATION) - alternative to DTEND
+    pub summary: Option<String>,      // Summary/title (SUMMARY)
+    pub description: Option<String>,  // Description (DESCRIPTION)
+    pub location: Option<String>,     // Location (LOCATION)
+
     // Classification and status
-    pub class: Option<EventClass>,              // Classification (CLASS)
-    pub status: Option<EventStatus>,            // Status (STATUS)
-    pub transp: Option<TimeTransparency>,       // Time transparency (TRANSP)
-    pub priority: Option<u8>,                   // Priority 0-9 (PRIORITY)
-    
+    pub class: Option<EventClass>,        // Classification (CLASS)
+    pub status: Option<EventStatus>,      // Status (STATUS)
+    pub transp: Option<TimeTransparency>, // Time transparency (TRANSP)
+    pub priority: Option<u8>,             // Priority 0-9 (PRIORITY)
+
     // People and organization
-    pub organizer: Option<CalendarUser>,        // Organizer (ORGANIZER)
-    pub attendees: Vec<Attendee>,               // Attendees (ATTENDEE)
-    pub contact: Option<String>,                // Contact information (CONTACT)
-    
+    pub organizer: Option<CalendarUser>, // Organizer (ORGANIZER)
+    pub attendees: Vec<Attendee>,        // Attendees (ATTENDEE)
+    pub contact: Option<String>,         // Contact information (CONTACT)
+
     // Categorization and relationships
-    pub categories: Vec<String>,                // Categories (CATEGORIES)
-    pub comment: Option<String>,                // Comment (COMMENT)
-    pub resources: Vec<String>,                 // Resources (RESOURCES)
-    pub related_to: Option<String>,             // Related component (RELATED-TO)
-    pub url: Option<String>,                    // URL (URL)
-    
+    pub categories: Vec<String>,    // Categories (CATEGORIES)
+    pub comment: Option<String>,    // Comment (COMMENT)
+    pub resources: Vec<String>,     // Resources (RESOURCES)
+    pub related_to: Option<String>, // Related component (RELATED-TO)
+    pub url: Option<String>,        // URL (URL)
+
     // Geographical
-    pub geo: Option<GeographicPosition>,        // Geographic position (GEO)
-    
+    pub geo: Option<GeographicPosition>, // Geographic position (GEO)
+
     // Versioning and modification
-    pub sequence: Option<u32>,                  // Sequence number (SEQUENCE)
-    pub created: Option<DateTime<Utc>>,         // Creation time (CREATED)
-    pub last_modified: Option<DateTime<Utc>>,   // Last modified (LAST-MODIFIED)
-    
+    pub sequence: Option<u32>,                // Sequence number (SEQUENCE)
+    pub created: Option<DateTime<Utc>>,       // Creation time (CREATED)
+    pub last_modified: Option<DateTime<Utc>>, // Last modified (LAST-MODIFIED)
+
     // Recurrence
-    pub rrule: Option<String>,                  // Recurrence rule (RRULE)
-    pub rdate: Vec<DateTime<Utc>>,              // Recurrence dates (RDATE)
-    pub exdate: Vec<DateTime<Utc>>,             // Exception dates (EXDATE)
-    pub recurrence_id: Option<DateTime<Utc>>,   // Recurrence ID (RECURRENCE-ID)
-    
+    pub rrule: Option<String>,                // Recurrence rule (RRULE)
+    pub rdate: Vec<DateTime<Utc>>,            // Recurrence dates (RDATE)
+    pub exdate: Vec<DateTime<Utc>>,           // Exception dates (EXDATE)
+    pub recurrence_id: Option<DateTime<Utc>>, // Recurrence ID (RECURRENCE-ID)
+
     // Alarms and attachments
-    pub alarms: Vec<VAlarm>,                    // VALARM components
-    pub attachments: Vec<Attachment>,           // Attachments (ATTACH)
-    
+    pub alarms: Vec<VAlarm>,          // VALARM components
+    pub attachments: Vec<Attachment>, // Attachments (ATTACH)
+
     // CalDAV specific (for implementation)
-    pub etag: Option<String>,                   // ETag for CalDAV
-    pub href: Option<String>,                   // Href for CalDAV
-    pub calendar_path: Option<String>,          // Calendar path
-    pub all_day: bool,                          // All-day event flag
+    pub etag: Option<String>,          // ETag for CalDAV
+    pub href: Option<String>,          // Href for CalDAV
+    pub calendar_path: Option<String>, // Calendar path
+    pub all_day: bool,                 // All-day event flag
 }
 
 impl VEvent {
@@ -129,7 +129,9 @@ impl VEvent {
 
     /// Helper method to get display title (summary or "Untitled Event")
     pub fn get_title(&self) -> String {
-        self.summary.clone().unwrap_or_else(|| "Untitled Event".to_string())
+        self.summary
+            .clone()
+            .unwrap_or_else(|| "Untitled Event".to_string())
     }
 
     /// Helper method to get start date for UI compatibility
@@ -151,7 +153,7 @@ impl VEvent {
     pub fn get_status_display(&self) -> &'static str {
         match &self.status {
             Some(EventStatus::Tentative) => "Tentative",
-            Some(EventStatus::Confirmed) => "Confirmed", 
+            Some(EventStatus::Confirmed) => "Confirmed",
             Some(EventStatus::Cancelled) => "Cancelled",
             None => "Confirmed", // Default
         }
@@ -180,4 +182,4 @@ impl VEvent {
             Some(p) => format!("Priority {}", p),
         }
     }
-}
\ No newline at end of file
+}
diff --git a/frontend/src/app.rs b/frontend/src/app.rs
index 95da19b..6b2924f 100644
--- a/frontend/src/app.rs
+++ b/frontend/src/app.rs
@@ -1,11 +1,15 @@
-use yew::prelude::*;
-use yew_router::prelude::*;
+use crate::components::{
+    CalendarContextMenu, ContextMenu, CreateCalendarModal, CreateEventModal, DeleteAction,
+    EditAction, EventClass, EventContextMenu, EventCreationData, EventStatus, RecurrenceType,
+    ReminderType, RouteHandler, Sidebar, Theme, ViewMode,
+};
+use crate::models::ical::VEvent;
+use crate::services::{calendar_service::UserInfo, CalendarService};
+use chrono::NaiveDate;
 use gloo_storage::{LocalStorage, Storage};
 use web_sys::MouseEvent;
-use crate::components::{Sidebar, ViewMode, Theme, CreateCalendarModal, ContextMenu, EventContextMenu, CalendarContextMenu, CreateEventModal, EventCreationData, RouteHandler, EventStatus, EventClass, ReminderType, RecurrenceType, DeleteAction, EditAction};
-use crate::services::{CalendarService, calendar_service::UserInfo};
-use crate::models::ical::VEvent;
-use chrono::NaiveDate;
+use yew::prelude::*;
+use yew_router::prelude::*;
 
 fn get_theme_event_colors() -> Vec<String> {
     if let Some(window) = web_sys::window() {
@@ -25,21 +29,31 @@ fn get_theme_event_colors() -> Vec<String> {
             }
         }
     }
-    
+
     vec![
-        "#3B82F6".to_string(), "#10B981".to_string(), "#F59E0B".to_string(), "#EF4444".to_string(), 
-        "#8B5CF6".to_string(), "#06B6D4".to_string(), "#84CC16".to_string(), "#F97316".to_string(),
-        "#EC4899".to_string(), "#6366F1".to_string(), "#14B8A6".to_string(), "#F3B806".to_string(),
-        "#8B5A2B".to_string(), "#6B7280".to_string(), "#DC2626".to_string(), "#7C3AED".to_string()
+        "#3B82F6".to_string(),
+        "#10B981".to_string(),
+        "#F59E0B".to_string(),
+        "#EF4444".to_string(),
+        "#8B5CF6".to_string(),
+        "#06B6D4".to_string(),
+        "#84CC16".to_string(),
+        "#F97316".to_string(),
+        "#EC4899".to_string(),
+        "#6366F1".to_string(),
+        "#14B8A6".to_string(),
+        "#F3B806".to_string(),
+        "#8B5A2B".to_string(),
+        "#6B7280".to_string(),
+        "#DC2626".to_string(),
+        "#7C3AED".to_string(),
     ]
 }
 
 #[function_component]
 pub fn App() -> Html {
-    let auth_token = use_state(|| -> Option<String> {
-        LocalStorage::get("auth_token").ok()
-    });
-    
+    let auth_token = use_state(|| -> Option<String> { LocalStorage::get("auth_token").ok() });
+
     let user_info = use_state(|| -> Option<UserInfo> { None });
     let color_picker_open = use_state(|| -> Option<String> { None });
     let create_modal_open = use_state(|| false);
@@ -58,7 +72,7 @@ pub fn App() -> Html {
     let _recurring_edit_modal_open = use_state(|| false);
     let _recurring_edit_event = use_state(|| -> Option<VEvent> { None });
     let _recurring_edit_data = use_state(|| -> Option<EventCreationData> { None });
-    
+
     // Calendar view state - load from localStorage if available
     let current_view = use_state(|| {
         // Try to load saved view mode from localStorage
@@ -71,7 +85,7 @@ pub fn App() -> Html {
             ViewMode::Month // Default to month view
         }
     });
-    
+
     // Theme state - load from localStorage if available
     let current_theme = use_state(|| {
         // Try to load saved theme from localStorage
@@ -81,7 +95,7 @@ pub fn App() -> Html {
             Theme::Default // Default theme
         }
     });
-    
+
     let available_colors = use_state(|| get_theme_event_colors());
 
     let on_login = {
@@ -110,7 +124,7 @@ pub fn App() -> Html {
                 ViewMode::Week => "week",
             };
             let _ = LocalStorage::set("calendar_view_mode", view_string);
-            
+
             // Update state
             current_view.set(new_view);
         })
@@ -122,17 +136,17 @@ pub fn App() -> Html {
         Callback::from(move |new_theme: Theme| {
             // Save theme to localStorage
             let _ = LocalStorage::set("calendar_theme", new_theme.value());
-            
+
             // Apply theme to document root
             if let Some(document) = web_sys::window().and_then(|w| w.document()) {
                 if let Some(root) = document.document_element() {
                     let _ = root.set_attribute("data-theme", new_theme.value());
                 }
             }
-            
+
             // Update state
             current_theme.set(new_theme);
-            
+
             // Update available colors after theme change
             available_colors.set(get_theme_event_colors());
         })
@@ -155,17 +169,21 @@ pub fn App() -> Html {
     {
         let user_info = user_info.clone();
         let auth_token = auth_token.clone();
-        
+
         use_effect_with((*auth_token).clone(), move |token| {
             if let Some(token) = token {
                 let user_info = user_info.clone();
                 let token = token.clone();
-                
+
                 wasm_bindgen_futures::spawn_local(async move {
                     let calendar_service = CalendarService::new();
-                    
-                    let password = if let Ok(credentials_str) = LocalStorage::get::<String>("caldav_credentials") {
-                        if let Ok(credentials) = serde_json::from_str::<serde_json::Value>(&credentials_str) {
+
+                    let password = if let Ok(credentials_str) =
+                        LocalStorage::get::<String>("caldav_credentials")
+                    {
+                        if let Ok(credentials) =
+                            serde_json::from_str::<serde_json::Value>(&credentials_str)
+                        {
                             credentials["password"].as_str().unwrap_or("").to_string()
                         } else {
                             String::new()
@@ -173,12 +191,16 @@ pub fn App() -> Html {
                     } else {
                         String::new()
                     };
-                    
+
                     if !password.is_empty() {
                         match calendar_service.fetch_user_info(&token, &password).await {
                             Ok(mut info) => {
-                                if let Ok(saved_colors_json) = LocalStorage::get::<String>("calendar_colors") {
-                                    if let Ok(saved_info) = serde_json::from_str::<UserInfo>(&saved_colors_json) {
+                                if let Ok(saved_colors_json) =
+                                    LocalStorage::get::<String>("calendar_colors")
+                                {
+                                    if let Ok(saved_info) =
+                                        serde_json::from_str::<UserInfo>(&saved_colors_json)
+                                    {
                                         for saved_cal in &saved_info.calendars {
                                             for cal in &mut info.calendars {
                                                 if cal.path == saved_cal.path {
@@ -191,7 +213,9 @@ pub fn App() -> Html {
                                 user_info.set(Some(info));
                             }
                             Err(err) => {
-                                web_sys::console::log_1(&format!("Failed to fetch user info: {}", err).into());
+                                web_sys::console::log_1(
+                                    &format!("Failed to fetch user info: {}", err).into(),
+                                );
                             }
                         }
                     }
@@ -199,7 +223,7 @@ pub fn App() -> Html {
             } else {
                 user_info.set(None);
             }
-            
+
             || ()
         });
     }
@@ -211,17 +235,17 @@ pub fn App() -> Html {
         let calendar_context_menu_open = calendar_context_menu_open.clone();
         Callback::from(move |e: MouseEvent| {
             // Check if any context menu or color picker is open
-            let any_menu_open = color_picker_open.is_some() || 
-                               *context_menu_open || 
-                               *event_context_menu_open || 
-                               *calendar_context_menu_open;
-            
+            let any_menu_open = color_picker_open.is_some()
+                || *context_menu_open
+                || *event_context_menu_open
+                || *calendar_context_menu_open;
+
             if any_menu_open {
                 // Prevent the default action and stop event propagation
                 e.prevent_default();
                 e.stop_propagation();
             }
-            
+
             // Close all open menus/pickers
             color_picker_open.set(None);
             context_menu_open.set(false);
@@ -231,10 +255,10 @@ pub fn App() -> Html {
     };
 
     // Compute if any context menu is open
-    let any_context_menu_open = color_picker_open.is_some() || 
-                               *context_menu_open || 
-                               *event_context_menu_open || 
-                               *calendar_context_menu_open;
+    let any_context_menu_open = color_picker_open.is_some()
+        || *context_menu_open
+        || *event_context_menu_open
+        || *calendar_context_menu_open;
 
     let on_color_change = {
         let user_info = user_info.clone();
@@ -248,7 +272,7 @@ pub fn App() -> Html {
                     }
                 }
                 user_info.set(Some(info.clone()));
-                
+
                 if let Ok(json) = serde_json::to_string(&info) {
                     let _ = LocalStorage::set("calendar_colors", json);
                 }
@@ -317,14 +341,18 @@ pub fn App() -> Html {
         Callback::from(move |event_data: EventCreationData| {
             web_sys::console::log_1(&format!("Creating event: {:?}", event_data).into());
             create_event_modal_open.set(false);
-            
+
             if let Some(_token) = (*auth_token).clone() {
                 wasm_bindgen_futures::spawn_local(async move {
                     let _calendar_service = CalendarService::new();
-                    
+
                     // Get CalDAV password from storage
-                    let _password = if let Ok(credentials_str) = LocalStorage::get::<String>("caldav_credentials") {
-                        if let Ok(credentials) = serde_json::from_str::<serde_json::Value>(&credentials_str) {
+                    let _password = if let Ok(credentials_str) =
+                        LocalStorage::get::<String>("caldav_credentials")
+                    {
+                        if let Ok(credentials) =
+                            serde_json::from_str::<serde_json::Value>(&credentials_str)
+                        {
                             credentials["password"].as_str().unwrap_or("").to_string()
                         } else {
                             String::new()
@@ -332,30 +360,30 @@ pub fn App() -> Html {
                     } else {
                         String::new()
                     };
-                    
+
                     let params = event_data.to_create_event_params();
-                    let create_result = _calendar_service.create_event(
-                        &_token,
-                        &_password,
-                        params.0,  // title
-                        params.1,  // description
-                        params.2,  // start_date
-                        params.3,  // start_time
-                        params.4,  // end_date
-                        params.5,  // end_time
-                        params.6,  // location
-                        params.7,  // all_day
-                        params.8,  // status
-                        params.9,  // class
-                        params.10, // priority
-                        params.11, // organizer
-                        params.12, // attendees
-                        params.13, // categories
-                        params.14, // reminder
-                        params.15, // recurrence
-                        params.16, // recurrence_days
-                        params.17  // calendar_path
-                    ).await;
+                    let create_result = _calendar_service
+                        .create_event(
+                            &_token, &_password, params.0,  // title
+                            params.1,  // description
+                            params.2,  // start_date
+                            params.3,  // start_time
+                            params.4,  // end_date
+                            params.5,  // end_time
+                            params.6,  // location
+                            params.7,  // all_day
+                            params.8,  // status
+                            params.9,  // class
+                            params.10, // priority
+                            params.11, // organizer
+                            params.12, // attendees
+                            params.13, // categories
+                            params.14, // reminder
+                            params.15, // recurrence
+                            params.16, // recurrence_days
+                            params.17, // calendar_path
+                        )
+                        .await;
                     match create_result {
                         Ok(_) => {
                             web_sys::console::log_1(&"Event created successfully".into());
@@ -364,8 +392,13 @@ pub fn App() -> Html {
                             web_sys::window().unwrap().location().reload().unwrap();
                         }
                         Err(err) => {
-                            web_sys::console::error_1(&format!("Failed to create event: {}", err).into());
-                            web_sys::window().unwrap().alert_with_message(&format!("Failed to create event: {}", err)).unwrap();
+                            web_sys::console::error_1(
+                                &format!("Failed to create event: {}", err).into(),
+                            );
+                            web_sys::window()
+                                .unwrap()
+                                .alert_with_message(&format!("Failed to create event: {}", err))
+                                .unwrap();
                         }
                     }
                 });
@@ -375,161 +408,232 @@ pub fn App() -> Html {
 
     let on_event_update = {
         let auth_token = auth_token.clone();
-        Callback::from(move |(original_event, new_start, new_end, preserve_rrule, until_date, update_scope, occurrence_date): (VEvent, chrono::NaiveDateTime, chrono::NaiveDateTime, bool, Option<chrono::DateTime<chrono::Utc>>, Option<String>, Option<String>)| {
-            web_sys::console::log_1(&format!("Updating event: {} to new times: {} - {}", 
-                original_event.uid, 
-                new_start.format("%Y-%m-%d %H:%M"),
-                new_end.format("%Y-%m-%d %H:%M")).into());
-            
-            // Use the original UID for all updates
-            let backend_uid = original_event.uid.clone();
-            
-            if let Some(token) = (*auth_token).clone() {
-                let original_event = original_event.clone();
-                let backend_uid = backend_uid.clone();
-                wasm_bindgen_futures::spawn_local(async move {
-                    let calendar_service = CalendarService::new();
-                    
-                    // Get CalDAV password from storage
-                    let password = if let Ok(credentials_str) = LocalStorage::get::<String>("caldav_credentials") {
-                        if let Ok(credentials) = serde_json::from_str::<serde_json::Value>(&credentials_str) {
-                            credentials["password"].as_str().unwrap_or("").to_string()
+        Callback::from(
+            move |(
+                original_event,
+                new_start,
+                new_end,
+                preserve_rrule,
+                until_date,
+                update_scope,
+                occurrence_date,
+            ): (
+                VEvent,
+                chrono::NaiveDateTime,
+                chrono::NaiveDateTime,
+                bool,
+                Option<chrono::DateTime<chrono::Utc>>,
+                Option<String>,
+                Option<String>,
+            )| {
+                web_sys::console::log_1(
+                    &format!(
+                        "Updating event: {} to new times: {} - {}",
+                        original_event.uid,
+                        new_start.format("%Y-%m-%d %H:%M"),
+                        new_end.format("%Y-%m-%d %H:%M")
+                    )
+                    .into(),
+                );
+
+                // Use the original UID for all updates
+                let backend_uid = original_event.uid.clone();
+
+                if let Some(token) = (*auth_token).clone() {
+                    let original_event = original_event.clone();
+                    let backend_uid = backend_uid.clone();
+                    wasm_bindgen_futures::spawn_local(async move {
+                        let calendar_service = CalendarService::new();
+
+                        // Get CalDAV password from storage
+                        let password = if let Ok(credentials_str) =
+                            LocalStorage::get::<String>("caldav_credentials")
+                        {
+                            if let Ok(credentials) =
+                                serde_json::from_str::<serde_json::Value>(&credentials_str)
+                            {
+                                credentials["password"].as_str().unwrap_or("").to_string()
+                            } else {
+                                String::new()
+                            }
                         } else {
                             String::new()
-                        }
-                    } else {
-                        String::new()
-                    };
-                    
-                    // Convert local times to UTC for backend storage
-                    let start_utc = new_start.and_local_timezone(chrono::Local).unwrap().to_utc();
-                    let end_utc = new_end.and_local_timezone(chrono::Local).unwrap().to_utc();
-                    
-                    // Format UTC date and time strings for backend
-                    let start_date = start_utc.format("%Y-%m-%d").to_string();
-                    let start_time = start_utc.format("%H:%M").to_string();
-                    let end_date = end_utc.format("%Y-%m-%d").to_string();
-                    let end_time = end_utc.format("%H:%M").to_string();
-                    
-                    // Convert existing event data to string formats for the API
-                    let status_str = match original_event.status {
-                        Some(crate::models::ical::EventStatus::Tentative) => "TENTATIVE".to_string(),
-                        Some(crate::models::ical::EventStatus::Confirmed) => "CONFIRMED".to_string(),
-                        Some(crate::models::ical::EventStatus::Cancelled) => "CANCELLED".to_string(),
-                        None => "CONFIRMED".to_string(), // Default status
-                    };
-                    
-                    let class_str = match original_event.class {
-                        Some(crate::models::ical::EventClass::Public) => "PUBLIC".to_string(),
-                        Some(crate::models::ical::EventClass::Private) => "PRIVATE".to_string(),
-                        Some(crate::models::ical::EventClass::Confidential) => "CONFIDENTIAL".to_string(),
-                        None => "PUBLIC".to_string(), // Default class
-                    };
-                    
-                    // Convert reminders to string format
-                    let reminder_str = if !original_event.alarms.is_empty() {
-                        // Convert from VAlarm to minutes before
-                        "15".to_string() // TODO: Convert VAlarm trigger to minutes
-                    } else {
-                        "".to_string()
-                    };
-                    
-                    // Handle recurrence (keep existing)
-                    let recurrence_str = original_event.rrule.unwrap_or_default();
-                    let recurrence_days = vec![false; 7]; // Default - could be enhanced to parse existing recurrence
-                    
-                    // Determine if this is a recurring event that needs series endpoint
-                    let has_recurrence = !recurrence_str.is_empty() && recurrence_str.to_uppercase() != "NONE";
-                    
-                    let result = if let Some(scope) = update_scope.as_ref() {
-                        // Use series endpoint for recurring event operations
-                        if !has_recurrence {
-                            web_sys::console::log_1(&"⚠️ Warning: update_scope provided for non-recurring event, using regular endpoint instead".into());
-                            // Fall through to regular endpoint
-                            None
+                        };
+
+                        // Convert local times to UTC for backend storage
+                        let start_utc = new_start
+                            .and_local_timezone(chrono::Local)
+                            .unwrap()
+                            .to_utc();
+                        let end_utc = new_end.and_local_timezone(chrono::Local).unwrap().to_utc();
+
+                        // Format UTC date and time strings for backend
+                        let start_date = start_utc.format("%Y-%m-%d").to_string();
+                        let start_time = start_utc.format("%H:%M").to_string();
+                        let end_date = end_utc.format("%Y-%m-%d").to_string();
+                        let end_time = end_utc.format("%H:%M").to_string();
+
+                        // Convert existing event data to string formats for the API
+                        let status_str = match original_event.status {
+                            Some(crate::models::ical::EventStatus::Tentative) => {
+                                "TENTATIVE".to_string()
+                            }
+                            Some(crate::models::ical::EventStatus::Confirmed) => {
+                                "CONFIRMED".to_string()
+                            }
+                            Some(crate::models::ical::EventStatus::Cancelled) => {
+                                "CANCELLED".to_string()
+                            }
+                            None => "CONFIRMED".to_string(), // Default status
+                        };
+
+                        let class_str = match original_event.class {
+                            Some(crate::models::ical::EventClass::Public) => "PUBLIC".to_string(),
+                            Some(crate::models::ical::EventClass::Private) => "PRIVATE".to_string(),
+                            Some(crate::models::ical::EventClass::Confidential) => {
+                                "CONFIDENTIAL".to_string()
+                            }
+                            None => "PUBLIC".to_string(), // Default class
+                        };
+
+                        // Convert reminders to string format
+                        let reminder_str = if !original_event.alarms.is_empty() {
+                            // Convert from VAlarm to minutes before
+                            "15".to_string() // TODO: Convert VAlarm trigger to minutes
                         } else {
-                            Some(calendar_service.update_series(
-                                &token,
-                                &password,
-                                backend_uid.clone(),
-                                original_event.summary.clone().unwrap_or_default(),
-                                original_event.description.clone().unwrap_or_default(),
-                                start_date.clone(),
-                                start_time.clone(),
-                                end_date.clone(),
-                                end_time.clone(),
-                                original_event.location.clone().unwrap_or_default(),
-                                original_event.all_day,
-                                status_str.clone(),
-                                class_str.clone(),
-                                original_event.priority,
-                                original_event.organizer.as_ref().map(|o| o.cal_address.clone()).unwrap_or_default(),
-                                original_event.attendees.iter().map(|a| a.cal_address.clone()).collect::<Vec<_>>().join(","),
-                                original_event.categories.join(","),
-                                reminder_str.clone(),
-                                recurrence_str.clone(),
-                                original_event.calendar_path.clone(),
-                                scope.clone(),
-                                occurrence_date,
-                            ).await)
+                            "".to_string()
+                        };
+
+                        // Handle recurrence (keep existing)
+                        let recurrence_str = original_event.rrule.unwrap_or_default();
+                        let recurrence_days = vec![false; 7]; // Default - could be enhanced to parse existing recurrence
+
+                        // Determine if this is a recurring event that needs series endpoint
+                        let has_recurrence =
+                            !recurrence_str.is_empty() && recurrence_str.to_uppercase() != "NONE";
+
+                        let result = if let Some(scope) = update_scope.as_ref() {
+                            // Use series endpoint for recurring event operations
+                            if !has_recurrence {
+                                web_sys::console::log_1(&"⚠️ Warning: update_scope provided for non-recurring event, using regular endpoint instead".into());
+                                // Fall through to regular endpoint
+                                None
+                            } else {
+                                Some(
+                                    calendar_service
+                                        .update_series(
+                                            &token,
+                                            &password,
+                                            backend_uid.clone(),
+                                            original_event.summary.clone().unwrap_or_default(),
+                                            original_event.description.clone().unwrap_or_default(),
+                                            start_date.clone(),
+                                            start_time.clone(),
+                                            end_date.clone(),
+                                            end_time.clone(),
+                                            original_event.location.clone().unwrap_or_default(),
+                                            original_event.all_day,
+                                            status_str.clone(),
+                                            class_str.clone(),
+                                            original_event.priority,
+                                            original_event
+                                                .organizer
+                                                .as_ref()
+                                                .map(|o| o.cal_address.clone())
+                                                .unwrap_or_default(),
+                                            original_event
+                                                .attendees
+                                                .iter()
+                                                .map(|a| a.cal_address.clone())
+                                                .collect::<Vec<_>>()
+                                                .join(","),
+                                            original_event.categories.join(","),
+                                            reminder_str.clone(),
+                                            recurrence_str.clone(),
+                                            original_event.calendar_path.clone(),
+                                            scope.clone(),
+                                            occurrence_date,
+                                        )
+                                        .await,
+                                )
+                            }
+                        } else {
+                            None
+                        };
+
+                        let result = if let Some(series_result) = result {
+                            series_result
+                        } else {
+                            // Use regular endpoint
+                            calendar_service
+                                .update_event(
+                                    &token,
+                                    &password,
+                                    backend_uid,
+                                    original_event.summary.unwrap_or_default(),
+                                    original_event.description.unwrap_or_default(),
+                                    start_date,
+                                    start_time,
+                                    end_date,
+                                    end_time,
+                                    original_event.location.unwrap_or_default(),
+                                    original_event.all_day,
+                                    status_str,
+                                    class_str,
+                                    original_event.priority,
+                                    original_event
+                                        .organizer
+                                        .as_ref()
+                                        .map(|o| o.cal_address.clone())
+                                        .unwrap_or_default(),
+                                    original_event
+                                        .attendees
+                                        .iter()
+                                        .map(|a| a.cal_address.clone())
+                                        .collect::<Vec<_>>()
+                                        .join(","),
+                                    original_event.categories.join(","),
+                                    reminder_str,
+                                    recurrence_str,
+                                    recurrence_days,
+                                    original_event.calendar_path,
+                                    original_event.exdate.clone(),
+                                    if preserve_rrule {
+                                        Some("update_series".to_string())
+                                    } else {
+                                        Some("this_and_future".to_string())
+                                    },
+                                    until_date,
+                                )
+                                .await
+                        };
+
+                        match result {
+                            Ok(_) => {
+                                web_sys::console::log_1(&"Event updated successfully".into());
+                                // Add small delay before reload to let any pending requests complete
+                                wasm_bindgen_futures::spawn_local(async {
+                                    gloo_timers::future::sleep(std::time::Duration::from_millis(
+                                        100,
+                                    ))
+                                    .await;
+                                    web_sys::window().unwrap().location().reload().unwrap();
+                                });
+                            }
+                            Err(err) => {
+                                web_sys::console::error_1(
+                                    &format!("Failed to update event: {}", err).into(),
+                                );
+                                web_sys::window()
+                                    .unwrap()
+                                    .alert_with_message(&format!("Failed to update event: {}", err))
+                                    .unwrap();
+                            }
                         }
-                    } else {
-                        None
-                    };
-                    
-                    let result = if let Some(series_result) = result {
-                        series_result
-                    } else {
-                        // Use regular endpoint
-                        calendar_service.update_event(
-                            &token,
-                            &password,
-                            backend_uid,
-                            original_event.summary.unwrap_or_default(),
-                            original_event.description.unwrap_or_default(),
-                            start_date,
-                            start_time,
-                            end_date,
-                            end_time,
-                            original_event.location.unwrap_or_default(),
-                            original_event.all_day,
-                            status_str,
-                            class_str,
-                            original_event.priority,
-                            original_event.organizer.as_ref().map(|o| o.cal_address.clone()).unwrap_or_default(),
-                            original_event.attendees.iter().map(|a| a.cal_address.clone()).collect::<Vec<_>>().join(","),
-                            original_event.categories.join(","),
-                            reminder_str,
-                            recurrence_str,
-                            recurrence_days,
-                            original_event.calendar_path,
-                            original_event.exdate.clone(),
-                            if preserve_rrule { 
-                                Some("update_series".to_string()) 
-                            } else { 
-                                Some("this_and_future".to_string()) 
-                            },
-                            until_date
-                        ).await
-                    };
-                    
-                    match result {
-                        Ok(_) => {
-                            web_sys::console::log_1(&"Event updated successfully".into());
-                            // Add small delay before reload to let any pending requests complete
-                            wasm_bindgen_futures::spawn_local(async {
-                                gloo_timers::future::sleep(std::time::Duration::from_millis(100)).await;
-                                web_sys::window().unwrap().location().reload().unwrap();
-                            });
-                        }
-                        Err(err) => {
-                            web_sys::console::error_1(&format!("Failed to update event: {}", err).into());
-                            web_sys::window().unwrap().alert_with_message(&format!("Failed to update event: {}", err)).unwrap();
-                        }
-                    }
-                });
-            }
-        })
+                    });
+                }
+            },
+        )
     };
 
     let refresh_calendars = {
@@ -538,12 +642,16 @@ pub fn App() -> Html {
         Callback::from(move |_| {
             if let Some(token) = (*auth_token).clone() {
                 let user_info = user_info.clone();
-                
+
                 wasm_bindgen_futures::spawn_local(async move {
                     let calendar_service = CalendarService::new();
-                    
-                    let password = if let Ok(credentials_str) = LocalStorage::get::<String>("caldav_credentials") {
-                        if let Ok(credentials) = serde_json::from_str::<serde_json::Value>(&credentials_str) {
+
+                    let password = if let Ok(credentials_str) =
+                        LocalStorage::get::<String>("caldav_credentials")
+                    {
+                        if let Ok(credentials) =
+                            serde_json::from_str::<serde_json::Value>(&credentials_str)
+                        {
                             credentials["password"].as_str().unwrap_or("").to_string()
                         } else {
                             String::new()
@@ -551,11 +659,15 @@ pub fn App() -> Html {
                     } else {
                         String::new()
                     };
-                    
+
                     match calendar_service.fetch_user_info(&token, &password).await {
                         Ok(mut info) => {
-                            if let Ok(saved_colors_json) = LocalStorage::get::<String>("calendar_colors") {
-                                if let Ok(saved_info) = serde_json::from_str::<UserInfo>(&saved_colors_json) {
+                            if let Ok(saved_colors_json) =
+                                LocalStorage::get::<String>("calendar_colors")
+                            {
+                                if let Ok(saved_info) =
+                                    serde_json::from_str::<UserInfo>(&saved_colors_json)
+                                {
                                     for saved_cal in &saved_info.calendars {
                                         for cal in &mut info.calendars {
                                             if cal.path == saved_cal.path {
@@ -568,7 +680,9 @@ pub fn App() -> Html {
                             user_info.set(Some(info));
                         }
                         Err(err) => {
-                            web_sys::console::log_1(&format!("Failed to refresh calendars: {}", err).into());
+                            web_sys::console::log_1(
+                                &format!("Failed to refresh calendars: {}", err).into(),
+                            );
                         }
                     }
                 });
@@ -577,8 +691,10 @@ pub fn App() -> Html {
     };
 
     // Debug logging
-    web_sys::console::log_1(&format!("App rendering: auth_token = {:?}", auth_token.is_some()).into());
-    
+    web_sys::console::log_1(
+        &format!("App rendering: auth_token = {:?}", auth_token.is_some()).into(),
+    );
+
     html! {
         <BrowserRouter>
             <div class="app" onclick={on_outside_click}>
@@ -604,7 +720,7 @@ pub fn App() -> Html {
                                     on_theme_change={on_theme_change}
                                 />
                                 <main class="app-main">
-                                    <RouteHandler 
+                                    <RouteHandler
                                         auth_token={(*auth_token).clone()}
                                         user_info={(*user_info).clone()}
                                         on_login={on_login.clone()}
@@ -621,7 +737,7 @@ pub fn App() -> Html {
                     } else {
                         html! {
                             <div class="login-layout">
-                                <RouteHandler 
+                                <RouteHandler
                                     auth_token={(*auth_token).clone()}
                                     user_info={(*user_info).clone()}
                                     on_login={on_login.clone()}
@@ -635,8 +751,8 @@ pub fn App() -> Html {
                         }
                     }
                 }
-                
-                <CreateCalendarModal 
+
+                <CreateCalendarModal
                     is_open={*create_modal_open}
                     on_close={Callback::from({
                         let create_modal_open = create_modal_open.clone();
@@ -650,10 +766,10 @@ pub fn App() -> Html {
                             if let Some(token) = (*auth_token).clone() {
                                 let refresh_calendars = refresh_calendars.clone();
                                 let create_modal_open = create_modal_open.clone();
-                                
+
                                 wasm_bindgen_futures::spawn_local(async move {
                                     let calendar_service = CalendarService::new();
-                                    
+
                                     let password = if let Ok(credentials_str) = LocalStorage::get::<String>("caldav_credentials") {
                                         if let Ok(credentials) = serde_json::from_str::<serde_json::Value>(&credentials_str) {
                                             credentials["password"].as_str().unwrap_or("").to_string()
@@ -663,7 +779,7 @@ pub fn App() -> Html {
                                     } else {
                                         String::new()
                                     };
-                                    
+
                                     match calendar_service.create_calendar(&token, &password, name, description, color).await {
                                         Ok(_) => {
                                             web_sys::console::log_1(&"Calendar created successfully!".into());
@@ -681,8 +797,8 @@ pub fn App() -> Html {
                     })}
                     available_colors={available_colors.iter().map(|c| c.to_string()).collect::<Vec<_>>()}
                 />
-                
-                <ContextMenu 
+
+                <ContextMenu
                     is_open={*context_menu_open}
                     x={context_menu_pos.0}
                     y={context_menu_pos.1}
@@ -697,10 +813,10 @@ pub fn App() -> Html {
                         move |_: MouseEvent| {
                             if let (Some(token), Some(calendar_path)) = ((*auth_token).clone(), (*context_menu_calendar_path).clone()) {
                                 let refresh_calendars = refresh_calendars.clone();
-                                
+
                                 wasm_bindgen_futures::spawn_local(async move {
                                     let calendar_service = CalendarService::new();
-                                    
+
                                     let password = if let Ok(credentials_str) = LocalStorage::get::<String>("caldav_credentials") {
                                         if let Ok(credentials) = serde_json::from_str::<serde_json::Value>(&credentials_str) {
                                             credentials["password"].as_str().unwrap_or("").to_string()
@@ -710,7 +826,7 @@ pub fn App() -> Html {
                                     } else {
                                         String::new()
                                     };
-                                    
+
                                     match calendar_service.delete_calendar(&token, &password, calendar_path).await {
                                         Ok(_) => {
                                             web_sys::console::log_1(&"Calendar deleted successfully!".into());
@@ -725,8 +841,8 @@ pub fn App() -> Html {
                         }
                     })}
                 />
-                
-                <EventContextMenu 
+
+                <EventContextMenu
                     is_open={*event_context_menu_open}
                     x={event_context_menu_pos.0}
                     y={event_context_menu_pos.1}
@@ -756,17 +872,17 @@ pub fn App() -> Html {
                             if let (Some(token), Some(event)) = ((*auth_token).clone(), (*event_context_menu_event).clone()) {
                                 let _refresh_calendars = refresh_calendars.clone();
                                 let event_context_menu_open = event_context_menu_open.clone();
-                                
+
                                 // Log the delete action for now - we'll implement different behaviors later
                                 match delete_action {
                                     DeleteAction::DeleteThis => web_sys::console::log_1(&"Delete this event".into()),
                                     DeleteAction::DeleteFollowing => web_sys::console::log_1(&"Delete following events".into()),
                                     DeleteAction::DeleteSeries => web_sys::console::log_1(&"Delete entire series".into()),
                                 }
-                                
+
                                 wasm_bindgen_futures::spawn_local(async move {
                                     let calendar_service = CalendarService::new();
-                                    
+
                                     let password = if let Ok(credentials_str) = LocalStorage::get::<String>("caldav_credentials") {
                                         if let Ok(credentials) = serde_json::from_str::<serde_json::Value>(&credentials_str) {
                                             credentials["password"].as_str().unwrap_or("").to_string()
@@ -776,7 +892,7 @@ pub fn App() -> Html {
                                     } else {
                                         String::new()
                                     };
-                                    
+
                                     if let (Some(calendar_path), Some(event_href)) = (&event.calendar_path, &event.href) {
                                         // Convert delete action to string and get occurrence date
                                         let action_str = match delete_action {
@@ -784,31 +900,31 @@ pub fn App() -> Html {
                                             DeleteAction::DeleteFollowing => "delete_following".to_string(),
                                             DeleteAction::DeleteSeries => "delete_series".to_string(),
                                         };
-                                        
+
                                         // Get the occurrence date from the clicked event
                                         let occurrence_date = Some(event.dtstart.date_naive().format("%Y-%m-%d").to_string());
-                                        
+
                                         web_sys::console::log_1(&format!("🔄 Delete action: {}", action_str).into());
                                         web_sys::console::log_1(&format!("🔄 Event UID: {}", event.uid).into());
                                         web_sys::console::log_1(&format!("🔄 Event start: {}", event.dtstart).into());
                                         web_sys::console::log_1(&format!("🔄 Occurrence date: {:?}", occurrence_date).into());
-                                        
+
                                         match calendar_service.delete_event(
-                                            &token, 
-                                            &password, 
-                                            calendar_path.clone(), 
+                                            &token,
+                                            &password,
+                                            calendar_path.clone(),
                                             event_href.clone(),
                                             action_str,
                                             occurrence_date
                                         ).await {
                                             Ok(message) => {
                                                 web_sys::console::log_1(&format!("Delete response: {}", message).into());
-                                                
+
                                                 // Show the message to the user to explain what actually happened
                                                 if message.contains("Warning") {
                                                     web_sys::window().unwrap().alert_with_message(&message).unwrap();
                                                 }
-                                                
+
                                                 // Close the context menu
                                                 event_context_menu_open.set(false);
                                                 // Force a page reload to refresh the calendar events
@@ -827,8 +943,8 @@ pub fn App() -> Html {
                         }
                     })}
                 />
-                
-                <CalendarContextMenu 
+
+                <CalendarContextMenu
                     is_open={*calendar_context_menu_open}
                     x={calendar_context_menu_pos.0}
                     y={calendar_context_menu_pos.1}
@@ -838,8 +954,8 @@ pub fn App() -> Html {
                     })}
                     on_create_event={on_create_event_click}
                 />
-                
-                <CreateEventModal 
+
+                <CreateEventModal
                     is_open={*create_event_modal_open}
                     selected_date={(*selected_date_for_event).clone()}
                     event_to_edit={(*event_context_menu_event).clone()}
@@ -866,11 +982,11 @@ pub fn App() -> Html {
                             create_event_modal_open.set(false);
                             event_context_menu_event.set(None);
                             event_edit_scope.set(None);
-                            
+
                             if let Some(token) = (*auth_token).clone() {
                                 wasm_bindgen_futures::spawn_local(async move {
                                     let calendar_service = CalendarService::new();
-                                    
+
                                     // Get CalDAV password from storage
                                     let password = if let Ok(credentials_str) = LocalStorage::get::<String>("caldav_credentials") {
                                         if let Ok(credentials) = serde_json::from_str::<serde_json::Value>(&credentials_str) {
@@ -881,33 +997,33 @@ pub fn App() -> Html {
                                     } else {
                                         String::new()
                                     };
-                                    
+
                                     // Convert local times to UTC for backend storage
                                     let start_local = updated_data.start_date.and_time(updated_data.start_time);
                                     let end_local = updated_data.end_date.and_time(updated_data.end_time);
-                                    
+
                                     let start_utc = start_local.and_local_timezone(chrono::Local).unwrap().to_utc();
                                     let end_utc = end_local.and_local_timezone(chrono::Local).unwrap().to_utc();
-                                    
+
                                     // Format UTC date and time strings for backend
                                     let start_date = start_utc.format("%Y-%m-%d").to_string();
                                     let start_time = start_utc.format("%H:%M").to_string();
                                     let end_date = end_utc.format("%Y-%m-%d").to_string();
                                     let end_time = end_utc.format("%H:%M").to_string();
-                                    
+
                                     // Convert enums to strings for backend
                                     let status_str = match updated_data.status {
                                         EventStatus::Tentative => "tentative",
                                         EventStatus::Cancelled => "cancelled",
                                         _ => "confirmed",
                                     }.to_string();
-                                    
+
                                     let class_str = match updated_data.class {
                                         EventClass::Private => "private",
                                         EventClass::Confidential => "confidential",
                                         _ => "public",
                                     }.to_string();
-                                    
+
                                     let reminder_str = match updated_data.reminder {
                                         ReminderType::Minutes15 => "15min",
                                         ReminderType::Minutes30 => "30min",
@@ -918,7 +1034,7 @@ pub fn App() -> Html {
                                         ReminderType::Week1 => "1week",
                                         _ => "none",
                                     }.to_string();
-                                    
+
                                     let recurrence_str = match updated_data.recurrence {
                                         RecurrenceType::Daily => "daily",
                                         RecurrenceType::Weekly => "weekly",
@@ -929,11 +1045,11 @@ pub fn App() -> Html {
 
                                     // Check if the calendar has changed
                                     let calendar_changed = original_event.calendar_path.as_ref() != updated_data.selected_calendar.as_ref();
-                                    
+
                                     if calendar_changed {
                                         // Calendar changed - need to delete from original and create in new
                                         web_sys::console::log_1(&"Calendar changed - performing delete + create".into());
-                                        
+
                                         // First delete from original calendar
                                         if let Some(original_calendar_path) = &original_event.calendar_path {
                                             if let Some(event_href) = &original_event.href {
@@ -942,12 +1058,12 @@ pub fn App() -> Html {
                                                     &password,
                                                     original_calendar_path.clone(),
                                                     event_href.clone(),
-                                                    "single".to_string(), // delete single occurrence 
+                                                    "single".to_string(), // delete single occurrence
                                                     None
                                                 ).await {
                                                     Ok(_) => {
                                                         web_sys::console::log_1(&"Original event deleted successfully".into());
-                                                        
+
                                                         // Now create the event in the new calendar
                                                         match calendar_service.create_event(
                                                             &token,
@@ -998,15 +1114,15 @@ pub fn App() -> Html {
                                     } else {
                                         // Calendar hasn't changed - check if we should use series endpoint
                                         let use_series_endpoint = updated_data.edit_scope.is_some() && original_event.rrule.is_some();
-                                        
+
                                         if use_series_endpoint {
                                             // Use series endpoint for recurring event modal edits
                                             let update_scope = match updated_data.edit_scope.as_ref().unwrap() {
                                                 EditAction::EditThis => "this_only",
-                                                EditAction::EditFuture => "this_and_future", 
+                                                EditAction::EditFuture => "this_and_future",
                                                 EditAction::EditAll => "all_in_series",
                                             };
-                                            
+
                                             // For single occurrence edits, we need the occurrence date
                                             let occurrence_date = if update_scope == "this_only" || update_scope == "this_and_future" {
                                                 // Use the original event's start date as the occurrence date
@@ -1014,7 +1130,7 @@ pub fn App() -> Html {
                                             } else {
                                                 None
                                             };
-                                            
+
                                             match calendar_service.update_series(
                                                 &token,
                                                 &password,
@@ -1097,4 +1213,4 @@ pub fn App() -> Html {
             </div>
         </BrowserRouter>
     }
-}
\ No newline at end of file
+}
diff --git a/frontend/src/auth.rs b/frontend/src/auth.rs
index ba24dd8..a635464 100644
--- a/frontend/src/auth.rs
+++ b/frontend/src/auth.rs
@@ -34,14 +34,14 @@ impl AuthService {
         let base_url = option_env!("BACKEND_API_URL")
             .unwrap_or("http://localhost:3000/api")
             .to_string();
-        
+
         Self { base_url }
     }
 
     pub async fn login(&self, request: CalDAVLoginRequest) -> Result<AuthResponse, String> {
         self.post_json("/auth/login", &request).await
     }
-    
+
     // Helper method for POST requests with JSON body
     async fn post_json<T: Serialize, R: for<'de> Deserialize<'de>>(
         &self,
@@ -49,9 +49,9 @@ impl AuthService {
         body: &T,
     ) -> Result<R, String> {
         let window = web_sys::window().ok_or("No global window exists")?;
-        
-        let json_body = serde_json::to_string(body)
-            .map_err(|e| format!("JSON serialization failed: {}", e))?;
+
+        let json_body =
+            serde_json::to_string(body).map_err(|e| format!("JSON serialization failed: {}", e))?;
 
         let opts = RequestInit::new();
         opts.set_method("POST");
@@ -62,23 +62,27 @@ impl AuthService {
         let request = Request::new_with_str_and_init(&url, &opts)
             .map_err(|e| format!("Request creation failed: {:?}", e))?;
 
-        request.headers().set("Content-Type", "application/json")
+        request
+            .headers()
+            .set("Content-Type", "application/json")
             .map_err(|e| format!("Header setting failed: {:?}", e))?;
 
         let resp_value = JsFuture::from(window.fetch_with_request(&request))
             .await
             .map_err(|e| format!("Network request failed: {:?}", e))?;
 
-        let resp: Response = resp_value.dyn_into()
+        let resp: Response = resp_value
+            .dyn_into()
             .map_err(|e| format!("Response cast failed: {:?}", e))?;
 
-        let text = JsFuture::from(resp.text()
-            .map_err(|e| format!("Text extraction failed: {:?}", e))?)
-            .await
-            .map_err(|e| format!("Text promise failed: {:?}", e))?;
+        let text = JsFuture::from(
+            resp.text()
+                .map_err(|e| format!("Text extraction failed: {:?}", e))?,
+        )
+        .await
+        .map_err(|e| format!("Text promise failed: {:?}", e))?;
 
-        let text_string = text.as_string()
-            .ok_or("Response text is not a string")?;
+        let text_string = text.as_string().ok_or("Response text is not a string")?;
 
         if resp.ok() {
             serde_json::from_str::<R>(&text_string)
@@ -92,4 +96,4 @@ impl AuthService {
             }
         }
     }
-}
\ No newline at end of file
+}
diff --git a/frontend/src/components/calendar.rs b/frontend/src/components/calendar.rs
index 62767fc..b1a4209 100644
--- a/frontend/src/components/calendar.rs
+++ b/frontend/src/components/calendar.rs
@@ -1,19 +1,16 @@
-use yew::prelude::*;
-use chrono::{Datelike, Local, NaiveDate, Duration};
+use crate::components::{
+    CalendarHeader, CreateEventModal, EventCreationData, EventModal, MonthView, ViewMode, WeekView,
+};
+use crate::models::ical::VEvent;
+use crate::services::{calendar_service::UserInfo, CalendarService};
+use chrono::{Datelike, Duration, Local, NaiveDate};
+use gloo_storage::{LocalStorage, Storage};
 use std::collections::HashMap;
 use web_sys::MouseEvent;
-use crate::services::calendar_service::UserInfo;
-use crate::models::ical::VEvent;
-use crate::components::{EventModal, ViewMode, CalendarHeader, MonthView, WeekView, CreateEventModal, EventCreationData};
-use gloo_storage::{LocalStorage, Storage};
+use yew::prelude::*;
 
 #[derive(Properties, PartialEq)]
 pub struct CalendarProps {
-    #[prop_or_default]
-    pub events: HashMap<NaiveDate, Vec<VEvent>>,
-    pub on_event_click: Callback<VEvent>,
-    #[prop_or_default]
-    pub refreshing_event_uid: Option<String>,
     #[prop_or_default]
     pub user_info: Option<UserInfo>,
     #[prop_or_default]
@@ -25,7 +22,17 @@ pub struct CalendarProps {
     #[prop_or_default]
     pub on_create_event_request: Option<Callback<EventCreationData>>,
     #[prop_or_default]
-    pub on_event_update_request: Option<Callback<(VEvent, chrono::NaiveDateTime, chrono::NaiveDateTime, bool, Option<chrono::DateTime<chrono::Utc>>, Option<String>, Option<String>)>>,
+    pub on_event_update_request: Option<
+        Callback<(
+            VEvent,
+            chrono::NaiveDateTime,
+            chrono::NaiveDateTime,
+            bool,
+            Option<chrono::DateTime<chrono::Utc>>,
+            Option<String>,
+            Option<String>,
+        )>,
+    >,
     #[prop_or_default]
     pub context_menus_open: bool,
 }
@@ -33,6 +40,12 @@ pub struct CalendarProps {
 #[function_component]
 pub fn Calendar(props: &CalendarProps) -> Html {
     let today = Local::now().date_naive();
+    
+    // Event management state
+    let events = use_state(|| HashMap::<NaiveDate, Vec<VEvent>>::new());
+    let loading = use_state(|| true);
+    let error = use_state(|| None::<String>);
+    let refreshing_event_uid = use_state(|| None::<String>);
     // Track the currently selected date (the actual day the user has selected)
     let selected_date = use_state(|| {
         // Try to load saved selected date from localStorage
@@ -55,20 +68,19 @@ pub fn Calendar(props: &CalendarProps) -> Html {
             }
         }
     });
-    
+
     // Track the display date (what to show in the view)
-    let current_date = use_state(|| {
-        match props.view {
-            ViewMode::Month => selected_date.with_day(1).unwrap_or(*selected_date),
-            ViewMode::Week => *selected_date,
-        }
+    let current_date = use_state(|| match props.view {
+        ViewMode::Month => selected_date.with_day(1).unwrap_or(*selected_date),
+        ViewMode::Week => *selected_date,
     });
     let selected_event = use_state(|| None::<VEvent>);
-    
+
     // State for create event modal
     let show_create_modal = use_state(|| false);
-    let create_event_data = use_state(|| None::<(chrono::NaiveDate, chrono::NaiveTime, chrono::NaiveTime)>);
-    
+    let create_event_data =
+        use_state(|| None::<(chrono::NaiveDate, chrono::NaiveTime, chrono::NaiveTime)>);
+
     // State for time increment snapping (15 or 30 minutes)
     let time_increment = use_state(|| {
         // Try to load saved time increment from localStorage
@@ -82,7 +94,155 @@ pub fn Calendar(props: &CalendarProps) -> Html {
             15
         }
     });
-    
+
+    // Fetch events when current_date changes
+    {
+        let events = events.clone();
+        let loading = loading.clone();
+        let error = error.clone();
+        let current_date = current_date.clone();
+        
+        use_effect_with((*current_date, props.view.clone()), move |(date, _view)| {
+            let auth_token: Option<String> = LocalStorage::get("auth_token").ok();
+            let date = *date; // Clone the date to avoid lifetime issues
+            
+            if let Some(token) = auth_token {
+                let events = events.clone();
+                let loading = loading.clone();
+                let error = error.clone();
+                
+                wasm_bindgen_futures::spawn_local(async move {
+                    let calendar_service = CalendarService::new();
+
+                    let password = if let Ok(credentials_str) =
+                        LocalStorage::get::<String>("caldav_credentials")
+                    {
+                        if let Ok(credentials) =
+                            serde_json::from_str::<serde_json::Value>(&credentials_str)
+                        {
+                            credentials["password"].as_str().unwrap_or("").to_string()
+                        } else {
+                            String::new()
+                        }
+                    } else {
+                        String::new()
+                    };
+
+                    let current_year = date.year();
+                    let current_month = date.month();
+
+                    match calendar_service
+                        .fetch_events_for_month_vevent(
+                            &token,
+                            &password,
+                            current_year,
+                            current_month,
+                        )
+                        .await
+                    {
+                        Ok(vevents) => {
+                            let grouped_events = CalendarService::group_events_by_date(vevents);
+                            events.set(grouped_events);
+                            loading.set(false);
+                        }
+                        Err(err) => {
+                            error.set(Some(format!("Failed to load events: {}", err)));
+                            loading.set(false);
+                        }
+                    }
+                });
+            } else {
+                loading.set(false);
+                error.set(Some("No authentication token found".to_string()));
+            }
+
+            || ()
+        });
+    }
+
+    // Handle event click to refresh individual events
+    let on_event_click = {
+        let events = events.clone();
+        let refreshing_event_uid = refreshing_event_uid.clone();
+        
+        Callback::from(move |event: VEvent| {
+            let auth_token: Option<String> = LocalStorage::get("auth_token").ok();
+            
+            if let Some(token) = auth_token {
+                let events = events.clone();
+                let refreshing_event_uid = refreshing_event_uid.clone();
+                let uid = event.uid.clone();
+
+                refreshing_event_uid.set(Some(uid.clone()));
+
+                wasm_bindgen_futures::spawn_local(async move {
+                    let calendar_service = CalendarService::new();
+
+                    let password = if let Ok(credentials_str) =
+                        LocalStorage::get::<String>("caldav_credentials")
+                    {
+                        if let Ok(credentials) =
+                            serde_json::from_str::<serde_json::Value>(&credentials_str)
+                        {
+                            credentials["password"].as_str().unwrap_or("").to_string()
+                        } else {
+                            String::new()
+                        }
+                    } else {
+                        String::new()
+                    };
+
+                    match calendar_service
+                        .refresh_event(&token, &password, &uid)
+                        .await
+                    {
+                        Ok(Some(refreshed_event)) => {
+                            let refreshed_vevent = refreshed_event;
+                            let mut updated_events = (*events).clone();
+
+                            for (_, day_events) in updated_events.iter_mut() {
+                                day_events.retain(|e| e.uid != uid);
+                            }
+
+                            if refreshed_vevent.rrule.is_some() {
+                                let new_occurrences =
+                                    CalendarService::expand_recurring_events(vec![
+                                        refreshed_vevent.clone(),
+                                    ]);
+
+                                for occurrence in new_occurrences {
+                                    let date = occurrence.get_date();
+                                    updated_events
+                                        .entry(date)
+                                        .or_insert_with(Vec::new)
+                                        .push(occurrence);
+                                }
+                            } else {
+                                let date = refreshed_vevent.get_date();
+                                updated_events
+                                    .entry(date)
+                                    .or_insert_with(Vec::new)
+                                    .push(refreshed_vevent);
+                            }
+
+                            events.set(updated_events);
+                        }
+                        Ok(None) => {
+                            let mut updated_events = (*events).clone();
+                            for (_, day_events) in updated_events.iter_mut() {
+                                day_events.retain(|e| e.uid != uid);
+                            }
+                            events.set(updated_events);
+                        }
+                        Err(_err) => {}
+                    }
+
+                    refreshing_event_uid.set(None);
+                });
+            }
+        })
+    };
+
     // Handle view mode changes - adjust current_date format when switching between month/week
     {
         let current_date = current_date.clone();
@@ -98,7 +258,7 @@ pub fn Calendar(props: &CalendarProps) -> Html {
             || {}
         });
     }
-    
+
     let on_prev = {
         let current_date = current_date.clone();
         let selected_date = selected_date.clone();
@@ -110,19 +270,22 @@ pub fn Calendar(props: &CalendarProps) -> Html {
                     let prev_month = *current_date - Duration::days(1);
                     let first_of_prev = prev_month.with_day(1).unwrap();
                     (first_of_prev, first_of_prev)
-                },
+                }
                 ViewMode::Week => {
                     // Go to previous week
                     let prev_week = *selected_date - Duration::weeks(1);
                     (prev_week, prev_week)
-                },
+                }
             };
             selected_date.set(new_selected);
             current_date.set(new_display);
-            let _ = LocalStorage::set("calendar_selected_date", new_selected.format("%Y-%m-%d").to_string());
+            let _ = LocalStorage::set(
+                "calendar_selected_date",
+                new_selected.format("%Y-%m-%d").to_string(),
+            );
         })
     };
-    
+
     let on_next = {
         let current_date = current_date.clone();
         let selected_date = selected_date.clone();
@@ -134,19 +297,23 @@ pub fn Calendar(props: &CalendarProps) -> Html {
                     let next_month = if current_date.month() == 12 {
                         NaiveDate::from_ymd_opt(current_date.year() + 1, 1, 1).unwrap()
                     } else {
-                        NaiveDate::from_ymd_opt(current_date.year(), current_date.month() + 1, 1).unwrap()
+                        NaiveDate::from_ymd_opt(current_date.year(), current_date.month() + 1, 1)
+                            .unwrap()
                     };
                     (next_month, next_month)
-                },
+                }
                 ViewMode::Week => {
                     // Go to next week
                     let next_week = *selected_date + Duration::weeks(1);
                     (next_week, next_week)
-                },
+                }
             };
             selected_date.set(new_selected);
             current_date.set(new_display);
-            let _ = LocalStorage::set("calendar_selected_date", new_selected.format("%Y-%m-%d").to_string());
+            let _ = LocalStorage::set(
+                "calendar_selected_date",
+                new_selected.format("%Y-%m-%d").to_string(),
+            );
         })
     };
 
@@ -160,15 +327,18 @@ pub fn Calendar(props: &CalendarProps) -> Html {
                 ViewMode::Month => {
                     let first_of_today = today.with_day(1).unwrap();
                     (today, first_of_today) // Select today, but display the month
-                },
+                }
                 ViewMode::Week => (today, today), // Select and display today
             };
             selected_date.set(new_selected);
             current_date.set(new_display);
-            let _ = LocalStorage::set("calendar_selected_date", new_selected.format("%Y-%m-%d").to_string());
+            let _ = LocalStorage::set(
+                "calendar_selected_date",
+                new_selected.format("%Y-%m-%d").to_string(),
+            );
         })
     };
-    
+
     // Handle time increment toggle
     let on_time_increment_toggle = {
         let time_increment = time_increment.clone();
@@ -179,32 +349,68 @@ pub fn Calendar(props: &CalendarProps) -> Html {
             let _ = LocalStorage::set("calendar_time_increment", next);
         })
     };
-    
+
     // Handle drag-to-create event
     let on_create_event = {
         let show_create_modal = show_create_modal.clone();
         let create_event_data = create_event_data.clone();
-        Callback::from(move |(_date, start_datetime, end_datetime): (NaiveDate, chrono::NaiveDateTime, chrono::NaiveDateTime)| {
-            // For drag-to-create, we don't need the temporary event approach
-            // Instead, just pass the local times directly via initial_time props
-            create_event_data.set(Some((start_datetime.date(), start_datetime.time(), end_datetime.time())));
-            show_create_modal.set(true);
-        })
+        Callback::from(
+            move |(_date, start_datetime, end_datetime): (
+                NaiveDate,
+                chrono::NaiveDateTime,
+                chrono::NaiveDateTime,
+            )| {
+                // For drag-to-create, we don't need the temporary event approach
+                // Instead, just pass the local times directly via initial_time props
+                create_event_data.set(Some((
+                    start_datetime.date(),
+                    start_datetime.time(),
+                    end_datetime.time(),
+                )));
+                show_create_modal.set(true);
+            },
+        )
     };
-    
+
     // Handle drag-to-move event
     let on_event_update = {
         let on_event_update_request = props.on_event_update_request.clone();
-        Callback::from(move |(event, new_start, new_end, preserve_rrule, until_date, update_scope, occurrence_date): (VEvent, chrono::NaiveDateTime, chrono::NaiveDateTime, bool, Option<chrono::DateTime<chrono::Utc>>, Option<String>, Option<String>)| {
-            if let Some(callback) = &on_event_update_request {
-                callback.emit((event, new_start, new_end, preserve_rrule, until_date, update_scope, occurrence_date));
-            }
-        })
+        Callback::from(
+            move |(
+                event,
+                new_start,
+                new_end,
+                preserve_rrule,
+                until_date,
+                update_scope,
+                occurrence_date,
+            ): (
+                VEvent,
+                chrono::NaiveDateTime,
+                chrono::NaiveDateTime,
+                bool,
+                Option<chrono::DateTime<chrono::Utc>>,
+                Option<String>,
+                Option<String>,
+            )| {
+                if let Some(callback) = &on_event_update_request {
+                    callback.emit((
+                        event,
+                        new_start,
+                        new_end,
+                        preserve_rrule,
+                        until_date,
+                        update_scope,
+                        occurrence_date,
+                    ));
+                }
+            },
+        )
     };
 
     html! {
         <div class={classes!("calendar", match props.view { ViewMode::Week => Some("week-view"), _ => None })}>
-            <CalendarHeader 
+            <CalendarHeader
                 current_date={*current_date}
                 view_mode={props.view.clone()}
                 on_prev={on_prev}
@@ -213,9 +419,22 @@ pub fn Calendar(props: &CalendarProps) -> Html {
                 time_increment={Some(*time_increment)}
                 on_time_increment_toggle={Some(on_time_increment_toggle)}
             />
-            
+
             {
-                match props.view {
+                if *loading {
+                    html! {
+                        <div class="calendar-loading">
+                            <p>{"Loading calendar events..."}</p>
+                        </div>
+                    }
+                } else if let Some(err) = (*error).clone() {
+                    html! {
+                        <div class="calendar-error">
+                            <p>{format!("Error: {}", err)}</p>
+                        </div>
+                    }
+                } else {
+                    match props.view {
                     ViewMode::Month => {
                         let on_day_select = {
                             let selected_date = selected_date.clone();
@@ -224,14 +443,14 @@ pub fn Calendar(props: &CalendarProps) -> Html {
                                 let _ = LocalStorage::set("calendar_selected_date", date.format("%Y-%m-%d").to_string());
                             })
                         };
-                        
+
                         html! {
                             <MonthView
                                 current_month={*current_date}
                                 today={today}
-                                events={props.events.clone()}
-                                on_event_click={props.on_event_click.clone()}
-                                refreshing_event_uid={props.refreshing_event_uid.clone()}
+                                events={(*events).clone()}
+                                on_event_click={on_event_click.clone()}
+                                refreshing_event_uid={(*refreshing_event_uid).clone()}
                                 user_info={props.user_info.clone()}
                                 on_event_context_menu={props.on_event_context_menu.clone()}
                                 on_calendar_context_menu={props.on_calendar_context_menu.clone()}
@@ -244,9 +463,9 @@ pub fn Calendar(props: &CalendarProps) -> Html {
                         <WeekView
                             current_date={*current_date}
                             today={today}
-                            events={props.events.clone()}
-                            on_event_click={props.on_event_click.clone()}
-                            refreshing_event_uid={props.refreshing_event_uid.clone()}
+                            events={(*events).clone()}
+                            on_event_click={on_event_click.clone()}
+                            refreshing_event_uid={(*refreshing_event_uid).clone()}
                             user_info={props.user_info.clone()}
                             on_event_context_menu={props.on_event_context_menu.clone()}
                             on_calendar_context_menu={props.on_calendar_context_menu.clone()}
@@ -257,11 +476,12 @@ pub fn Calendar(props: &CalendarProps) -> Html {
                             time_increment={*time_increment}
                         />
                     },
+                    }
                 }
             }
-            
+
             // Event details modal
-            <EventModal 
+            <EventModal
                 event={(*selected_event).clone()}
                 on_close={{
                     let selected_event_clone = selected_event.clone();
@@ -270,7 +490,7 @@ pub fn Calendar(props: &CalendarProps) -> Html {
                     })
                 }}
             />
-            
+
             // Create event modal
             <CreateEventModal
                 is_open={*show_create_modal}
@@ -294,7 +514,7 @@ pub fn Calendar(props: &CalendarProps) -> Html {
                     Callback::from(move |event_data: EventCreationData| {
                         show_create_modal.set(false);
                         create_event_data.set(None);
-                        
+
                         // Emit the create event request to parent
                         if let Some(callback) = &on_create_event_request {
                             callback.emit(event_data);
@@ -313,4 +533,4 @@ pub fn Calendar(props: &CalendarProps) -> Html {
             />
         </div>
     }
-}
\ No newline at end of file
+}
diff --git a/frontend/src/components/calendar_context_menu.rs b/frontend/src/components/calendar_context_menu.rs
index f1c13a5..7e9c080 100644
--- a/frontend/src/components/calendar_context_menu.rs
+++ b/frontend/src/components/calendar_context_menu.rs
@@ -1,5 +1,5 @@
-use yew::prelude::*;
 use web_sys::MouseEvent;
+use yew::prelude::*;
 
 #[derive(Properties, PartialEq)]
 pub struct CalendarContextMenuProps {
@@ -13,7 +13,7 @@ pub struct CalendarContextMenuProps {
 #[function_component(CalendarContextMenu)]
 pub fn calendar_context_menu(props: &CalendarContextMenuProps) -> Html {
     let menu_ref = use_node_ref();
-    
+
     if !props.is_open {
         return html! {};
     }
@@ -33,9 +33,9 @@ pub fn calendar_context_menu(props: &CalendarContextMenuProps) -> Html {
     };
 
     html! {
-        <div 
+        <div
             ref={menu_ref}
-            class="context-menu" 
+            class="context-menu"
             style={style}
         >
             <div class="context-menu-item context-menu-create" onclick={on_create_event_click}>
@@ -44,4 +44,4 @@ pub fn calendar_context_menu(props: &CalendarContextMenuProps) -> Html {
             </div>
         </div>
     }
-}
\ No newline at end of file
+}
diff --git a/frontend/src/components/calendar_header.rs b/frontend/src/components/calendar_header.rs
index a99089f..a81c6e4 100644
--- a/frontend/src/components/calendar_header.rs
+++ b/frontend/src/components/calendar_header.rs
@@ -1,7 +1,7 @@
-use yew::prelude::*;
-use chrono::{NaiveDate, Datelike};
 use crate::components::ViewMode;
+use chrono::{Datelike, NaiveDate};
 use web_sys::MouseEvent;
+use yew::prelude::*;
 
 #[derive(Properties, PartialEq)]
 pub struct CalendarHeaderProps {
@@ -18,7 +18,11 @@ pub struct CalendarHeaderProps {
 
 #[function_component(CalendarHeader)]
 pub fn calendar_header(props: &CalendarHeaderProps) -> Html {
-    let title = format!("{} {}", get_month_name(props.current_date.month()), props.current_date.year());
+    let title = format!(
+        "{} {}",
+        get_month_name(props.current_date.month()),
+        props.current_date.year()
+    );
 
     html! {
         <div class="calendar-header">
@@ -48,7 +52,7 @@ pub fn calendar_header(props: &CalendarHeaderProps) -> Html {
 fn get_month_name(month: u32) -> &'static str {
     match month {
         1 => "January",
-        2 => "February", 
+        2 => "February",
         3 => "March",
         4 => "April",
         5 => "May",
@@ -59,6 +63,6 @@ fn get_month_name(month: u32) -> &'static str {
         10 => "October",
         11 => "November",
         12 => "December",
-        _ => "Invalid"
+        _ => "Invalid",
     }
-}
\ No newline at end of file
+}
diff --git a/frontend/src/components/calendar_list_item.rs b/frontend/src/components/calendar_list_item.rs
index d5540b2..6119bcb 100644
--- a/frontend/src/components/calendar_list_item.rs
+++ b/frontend/src/components/calendar_list_item.rs
@@ -1,13 +1,13 @@
-use yew::prelude::*;
-use web_sys::MouseEvent;
 use crate::services::calendar_service::CalendarInfo;
+use web_sys::MouseEvent;
+use yew::prelude::*;
 
 #[derive(Properties, PartialEq)]
 pub struct CalendarListItemProps {
     pub calendar: CalendarInfo,
     pub color_picker_open: bool,
     pub on_color_change: Callback<(String, String)>, // (calendar_path, color)
-    pub on_color_picker_toggle: Callback<String>, // calendar_path
+    pub on_color_picker_toggle: Callback<String>,    // calendar_path
     pub available_colors: Vec<String>,
     pub on_context_menu: Callback<(MouseEvent, String)>, // (event, calendar_path)
 }
@@ -34,7 +34,7 @@ pub fn calendar_list_item(props: &CalendarListItemProps) -> Html {
 
     html! {
         <li key={props.calendar.path.clone()} oncontextmenu={on_context_menu}>
-            <span class="calendar-color" 
+            <span class="calendar-color"
                   style={format!("background-color: {}", props.calendar.color)}
                   onclick={on_color_click}>
                 {
@@ -46,14 +46,14 @@ pub fn calendar_list_item(props: &CalendarListItemProps) -> Html {
                                         let color_str = color.clone();
                                         let cal_path = props.calendar.path.clone();
                                         let on_color_change = props.on_color_change.clone();
-                                        
+
                                         let on_color_select = Callback::from(move |_: MouseEvent| {
                                             on_color_change.emit((cal_path.clone(), color_str.clone()));
                                         });
-                                        
+
                                         let is_selected = props.calendar.color == *color;
                                         let class_name = if is_selected { "color-option selected" } else { "color-option" };
-                                        
+
                                         html! {
                                             <div class={class_name}
                                                  style={format!("background-color: {}", color)}
@@ -72,4 +72,4 @@ pub fn calendar_list_item(props: &CalendarListItemProps) -> Html {
             <span class="calendar-name">{&props.calendar.display_name}</span>
         </li>
     }
-}
\ No newline at end of file
+}
diff --git a/frontend/src/components/context_menu.rs b/frontend/src/components/context_menu.rs
index 1fc9f8c..b0cd7dc 100644
--- a/frontend/src/components/context_menu.rs
+++ b/frontend/src/components/context_menu.rs
@@ -1,5 +1,5 @@
-use yew::prelude::*;
 use web_sys::MouseEvent;
+use yew::prelude::*;
 
 #[derive(Properties, PartialEq)]
 pub struct ContextMenuProps {
@@ -13,7 +13,7 @@ pub struct ContextMenuProps {
 #[function_component(ContextMenu)]
 pub fn context_menu(props: &ContextMenuProps) -> Html {
     let menu_ref = use_node_ref();
-    
+
     // Close menu when clicking outside (handled by parent component)
 
     if !props.is_open {
@@ -35,9 +35,9 @@ pub fn context_menu(props: &ContextMenuProps) -> Html {
     };
 
     html! {
-        <div 
+        <div
             ref={menu_ref}
-            class="context-menu" 
+            class="context-menu"
             style={style}
         >
             <div class="context-menu-item context-menu-delete" onclick={on_delete_click}>
@@ -45,4 +45,4 @@ pub fn context_menu(props: &ContextMenuProps) -> Html {
             </div>
         </div>
     }
-}
\ No newline at end of file
+}
diff --git a/frontend/src/components/create_calendar_modal.rs b/frontend/src/components/create_calendar_modal.rs
index ef94b96..679532c 100644
--- a/frontend/src/components/create_calendar_modal.rs
+++ b/frontend/src/components/create_calendar_modal.rs
@@ -39,30 +39,32 @@ pub fn CreateCalendarModal(props: &CreateCalendarModalProps) -> Html {
         let error_message = error_message.clone();
         let is_creating = is_creating.clone();
         let on_create = props.on_create.clone();
-        
+
         Callback::from(move |e: SubmitEvent| {
             e.prevent_default();
-            
+
             let name = (*calendar_name).trim();
             if name.is_empty() {
                 error_message.set(Some("Calendar name is required".to_string()));
                 return;
             }
-            
+
             if name.len() > 100 {
-                error_message.set(Some("Calendar name too long (max 100 characters)".to_string()));
+                error_message.set(Some(
+                    "Calendar name too long (max 100 characters)".to_string(),
+                ));
                 return;
             }
-            
+
             error_message.set(None);
             is_creating.set(true);
-            
+
             let desc = if (*description).trim().is_empty() {
                 None
             } else {
                 Some((*description).clone())
             };
-            
+
             on_create.emit((name.to_string(), desc, (*selected_color).clone()));
         })
     };
@@ -90,7 +92,7 @@ pub fn CreateCalendarModal(props: &CreateCalendarModalProps) -> Html {
                         {"×"}
                     </button>
                 </div>
-                
+
                 <form class="modal-body" onsubmit={on_submit}>
                     {
                         if let Some(ref error) = *error_message {
@@ -103,10 +105,10 @@ pub fn CreateCalendarModal(props: &CreateCalendarModalProps) -> Html {
                             html! {}
                         }
                     }
-                    
+
                     <div class="form-group">
                         <label for="calendar-name">{"Calendar Name *"}</label>
-                        <input 
+                        <input
                             id="calendar-name"
                             type="text"
                             value={(*calendar_name).clone()}
@@ -116,7 +118,7 @@ pub fn CreateCalendarModal(props: &CreateCalendarModalProps) -> Html {
                             disabled={*is_creating}
                         />
                     </div>
-                    
+
                     <div class="form-group">
                         <label for="calendar-description">{"Description"}</label>
                         <textarea
@@ -128,7 +130,7 @@ pub fn CreateCalendarModal(props: &CreateCalendarModalProps) -> Html {
                             disabled={*is_creating}
                         />
                     </div>
-                    
+
                     <div class="form-group">
                         <label>{"Calendar Color"}</label>
                         <div class="color-grid">
@@ -143,13 +145,13 @@ pub fn CreateCalendarModal(props: &CreateCalendarModalProps) -> Html {
                                             selected_color.set(Some(color.clone()));
                                         })
                                     };
-                                    
-                                    let class_name = if is_selected { 
-                                        "color-option selected" 
-                                    } else { 
-                                        "color-option" 
+
+                                    let class_name = if is_selected {
+                                        "color-option selected"
+                                    } else {
+                                        "color-option"
                                     };
-                                    
+
                                     html! {
                                         <button
                                             key={index}
@@ -165,18 +167,18 @@ pub fn CreateCalendarModal(props: &CreateCalendarModalProps) -> Html {
                         </div>
                         <p class="color-help-text">{"Optional: Choose a color for your calendar"}</p>
                     </div>
-                    
+
                     <div class="modal-actions">
-                        <button 
-                            type="button" 
+                        <button
+                            type="button"
                             class="cancel-button"
                             onclick={props.on_close.reform(|_| ())}
                             disabled={*is_creating}
                         >
                             {"Cancel"}
                         </button>
-                        <button 
-                            type="submit" 
+                        <button
+                            type="submit"
                             class="create-button"
                             disabled={*is_creating}
                         >
@@ -193,4 +195,4 @@ pub fn CreateCalendarModal(props: &CreateCalendarModalProps) -> Html {
             </div>
         </div>
     }
-}
\ No newline at end of file
+}
diff --git a/frontend/src/components/create_event_modal.rs b/frontend/src/components/create_event_modal.rs
index b676d2e..e4a55ec 100644
--- a/frontend/src/components/create_event_modal.rs
+++ b/frontend/src/components/create_event_modal.rs
@@ -1,10 +1,10 @@
-use yew::prelude::*;
-use web_sys::{HtmlInputElement, HtmlTextAreaElement, HtmlSelectElement};
-use wasm_bindgen::JsCast;
-use chrono::{NaiveDate, NaiveTime, Local, TimeZone, Utc, Datelike};
-use crate::services::calendar_service::CalendarInfo;
-use crate::models::ical::VEvent;
 use crate::components::EditAction;
+use crate::models::ical::VEvent;
+use crate::services::calendar_service::CalendarInfo;
+use chrono::{Datelike, Local, NaiveDate, NaiveTime, TimeZone, Utc};
+use wasm_bindgen::JsCast;
+use web_sys::{HtmlInputElement, HtmlSelectElement, HtmlTextAreaElement};
+use yew::prelude::*;
 
 #[derive(Properties, PartialEq)]
 pub struct CreateEventModalProps {
@@ -36,7 +36,6 @@ impl Default for EventStatus {
     }
 }
 
-
 #[derive(Clone, PartialEq, Debug)]
 pub enum EventClass {
     Public,
@@ -50,7 +49,6 @@ impl Default for EventClass {
     }
 }
 
-
 #[derive(Clone, PartialEq, Debug)]
 pub enum ReminderType {
     None,
@@ -84,7 +82,6 @@ impl Default for RecurrenceType {
     }
 }
 
-
 /// Parse RRULE string into recurrence components
 /// Example RRULE: "FREQ=WEEKLY;INTERVAL=2;BYDAY=MO,WE,FR;UNTIL=20231215T000000Z"
 #[derive(Debug, Default, Clone)]
@@ -103,17 +100,17 @@ fn parse_rrule(rrule: Option<&str>) -> ParsedRrule {
         interval: 1, // Default interval is 1
         ..Default::default()
     };
-    
+
     let Some(rrule_str) = rrule else {
         return parsed;
     };
-    
+
     // Split RRULE into parts: "FREQ=WEEKLY;INTERVAL=2;BYDAY=MO,WE"
     for part in rrule_str.split(';') {
         let mut key_value = part.split('=');
         let key = key_value.next().unwrap_or("");
         let value = key_value.next().unwrap_or("");
-        
+
         match key {
             "FREQ" => {
                 parsed.freq = match value {
@@ -145,9 +142,7 @@ fn parse_rrule(rrule: Option<&str>) -> ParsedRrule {
             }
             "BYDAY" => {
                 // Parse BYDAY: "MO,WE,FR" or "1MO,-1SU" (with position)
-                parsed.byday = value.split(',')
-                    .map(|s| s.trim().to_uppercase())
-                    .collect();
+                parsed.byday = value.split(',').map(|s| s.trim().to_uppercase()).collect();
             }
             "BYMONTHDAY" => {
                 // Parse BYMONTHDAY: "15" or "1,15,31"
@@ -161,7 +156,8 @@ fn parse_rrule(rrule: Option<&str>) -> ParsedRrule {
             }
             "BYMONTH" => {
                 // Parse BYMONTH: "1,3,5" (January, March, May)
-                parsed.bymonth = value.split(',')
+                parsed.bymonth = value
+                    .split(',')
                     .filter_map(|m| m.trim().parse::<u8>().ok())
                     .filter(|&m| m >= 1 && m <= 12)
                     .collect();
@@ -169,7 +165,7 @@ fn parse_rrule(rrule: Option<&str>) -> ParsedRrule {
             _ => {} // Ignore unknown parameters
         }
     }
-    
+
     parsed
 }
 
@@ -177,16 +173,16 @@ fn parse_rrule(rrule: Option<&str>) -> ParsedRrule {
 /// Maps RFC 5545 day codes to [Sun, Mon, Tue, Wed, Thu, Fri, Sat]
 fn byday_to_weekday_array(byday: &[String]) -> Vec<bool> {
     let mut weekdays = vec![false; 7];
-    
+
     for day_spec in byday {
         // Handle both simple days (MO, TU) and positioned days (1MO, -1SU)
         let day_code = if day_spec.len() > 2 {
             // Extract last 2 characters for positioned days like "1MO" -> "MO"
-            &day_spec[day_spec.len()-2..]
+            &day_spec[day_spec.len() - 2..]
         } else {
             day_spec
         };
-        
+
         let index = match day_code {
             "SU" => 0, // Sunday
             "MO" => 1, // Monday
@@ -197,10 +193,10 @@ fn byday_to_weekday_array(byday: &[String]) -> Vec<bool> {
             "SA" => 6, // Saturday
             _ => continue,
         };
-        
+
         weekdays[index] = true;
     }
-    
+
     weekdays
 }
 
@@ -208,20 +204,21 @@ fn byday_to_weekday_array(byday: &[String]) -> Vec<bool> {
 /// Maps month numbers to [Jan, Feb, Mar, ..., Dec]
 fn bymonth_to_monthly_array(bymonth: &[u8]) -> Vec<bool> {
     let mut months = vec![false; 12];
-    
+
     for &month in bymonth {
         if month >= 1 && month <= 12 {
             months[(month - 1) as usize] = true;
         }
     }
-    
+
     months
 }
 
 /// Extract positioned weekday from BYDAY for monthly recurrence
 /// Examples: "1MO" -> Some("1MO"), "2TU" -> Some("2TU"), "-1SU" -> Some("-1SU")
 fn extract_monthly_byday(byday: &[String]) -> Option<String> {
-    byday.iter()
+    byday
+        .iter()
         .find(|day| day.len() > 2) // Positioned days have length > 2
         .cloned()
 }
@@ -238,9 +235,11 @@ mod rrule_tests {
         assert_eq!(parsed.byday, vec!["MO", "WE", "FR"]);
     }
 
-    #[test] 
+    #[test]
     fn test_parse_complex_monthly() {
-        let parsed = parse_rrule(Some("FREQ=MONTHLY;INTERVAL=2;BYDAY=1MO;UNTIL=20241231T000000Z"));
+        let parsed = parse_rrule(Some(
+            "FREQ=MONTHLY;INTERVAL=2;BYDAY=1MO;UNTIL=20241231T000000Z",
+        ));
         assert_eq!(parsed.freq, RecurrenceType::Monthly);
         assert_eq!(parsed.interval, 2);
         assert_eq!(parsed.byday, vec!["1MO"]);
@@ -249,7 +248,8 @@ mod rrule_tests {
 
     #[test]
     fn test_byday_to_weekday_array() {
-        let weekdays = byday_to_weekday_array(&["MO".to_string(), "WE".to_string(), "FR".to_string()]);
+        let weekdays =
+            byday_to_weekday_array(&["MO".to_string(), "WE".to_string(), "FR".to_string()]);
         // [Sun, Mon, Tue, Wed, Thu, Fri, Sat]
         assert_eq!(weekdays, vec![false, true, false, true, false, true, false]);
     }
@@ -258,7 +258,7 @@ mod rrule_tests {
     fn test_extract_monthly_byday() {
         let byday = vec!["1MO".to_string(), "WE".to_string()];
         assert_eq!(extract_monthly_byday(&byday), Some("1MO".to_string()));
-        
+
         let byday_simple = vec!["MO".to_string(), "TU".to_string()];
         assert_eq!(extract_monthly_byday(&byday_simple), None);
     }
@@ -270,7 +270,7 @@ mod rrule_tests {
         data.recurrence_interval = 2;
         data.recurrence_days = vec![false, true, false, true, false, true, false]; // Mon, Wed, Fri
         data.recurrence_count = Some(10);
-        
+
         let rrule = data.build_rrule();
         assert!(rrule.contains("FREQ=WEEKLY"));
         assert!(rrule.contains("INTERVAL=2"));
@@ -284,7 +284,7 @@ mod rrule_tests {
         data.recurrence = RecurrenceType::Monthly;
         data.monthly_by_day = Some("1MO".to_string());
         data.recurrence_until = Some(NaiveDate::from_ymd_opt(2024, 12, 31).unwrap());
-        
+
         let rrule = data.build_rrule();
         assert!(rrule.contains("FREQ=MONTHLY"));
         assert!(rrule.contains("BYDAY=1MO"));
@@ -295,14 +295,15 @@ mod rrule_tests {
     fn test_build_rrule_yearly() {
         let mut data = EventCreationData::default();
         data.recurrence = RecurrenceType::Yearly;
-        data.yearly_by_month = vec![false, false, true, false, true, false, false, false, false, false, false, false]; // March, May
-        
+        data.yearly_by_month = vec![
+            false, false, true, false, true, false, false, false, false, false, false, false,
+        ]; // March, May
+
         let rrule = data.build_rrule();
         println!("YEARLY RRULE: {}", rrule);
         assert!(rrule.contains("FREQ=YEARLY"));
         assert!(rrule.contains("BYMONTH=3,5"));
     }
-
 }
 
 #[derive(Clone, PartialEq, Debug)]
@@ -319,21 +320,21 @@ pub struct EventCreationData {
     pub class: EventClass,
     pub priority: Option<u8>,
     pub organizer: String,
-    pub attendees: String, // Comma-separated list
+    pub attendees: String,  // Comma-separated list
     pub categories: String, // Comma-separated list
     pub reminder: ReminderType,
     pub recurrence: RecurrenceType,
     pub recurrence_days: Vec<bool>, // [Sun, Mon, Tue, Wed, Thu, Fri, Sat] for weekly recurrence
     pub selected_calendar: Option<String>, // Calendar path
-    
+
     // Advanced recurrence fields
     pub recurrence_interval: u32, // INTERVAL - every N (days/weeks/months/years)
     pub recurrence_until: Option<NaiveDate>, // UNTIL date
     pub recurrence_count: Option<u32>, // COUNT - number of occurrences
     pub monthly_by_day: Option<String>, // For monthly: "1MO" = first Monday, "2TU" = second Tuesday, etc.
     pub monthly_by_monthday: Option<u8>, // For monthly: day of month (1-31)
-    pub yearly_by_month: Vec<bool>, // For yearly: [Jan, Feb, Mar, ..., Dec]
-    
+    pub yearly_by_month: Vec<bool>,     // For yearly: [Jan, Feb, Mar, ..., Dec]
+
     // Edit scope and tracking fields
     pub edit_scope: Option<EditAction>,
     pub changed_fields: Vec<String>, // List of field names that were changed
@@ -344,7 +345,7 @@ impl Default for EventCreationData {
         let now = chrono::Local::now().naive_local();
         let start_time = NaiveTime::from_hms_opt(9, 0, 0).unwrap_or_default();
         let end_time = NaiveTime::from_hms_opt(10, 0, 0).unwrap_or_default();
-        
+
         Self {
             title: String::new(),
             description: String::new(),
@@ -364,7 +365,7 @@ impl Default for EventCreationData {
             recurrence: RecurrenceType::default(),
             recurrence_days: vec![false; 7], // [Sun, Mon, Tue, Wed, Thu, Fri, Sat] - all false by default
             selected_calendar: None,
-            
+
             // Advanced recurrence defaults
             recurrence_interval: 1,
             recurrence_until: None,
@@ -372,7 +373,7 @@ impl Default for EventCreationData {
             monthly_by_day: None,
             monthly_by_monthday: None,
             yearly_by_month: vec![false; 12], // [Jan, Feb, ..., Dec] - all false by default
-            
+
             // Edit scope and tracking defaults
             edit_scope: None,
             changed_fields: vec![],
@@ -386,50 +387,54 @@ impl EventCreationData {
         if matches!(self.recurrence, RecurrenceType::None) {
             return String::new();
         }
-        
+
         let mut parts = Vec::new();
-        
+
         // Add frequency (required)
         match self.recurrence {
             RecurrenceType::Daily => parts.push("FREQ=DAILY".to_string()),
-            RecurrenceType::Weekly => parts.push("FREQ=WEEKLY".to_string()),  
+            RecurrenceType::Weekly => parts.push("FREQ=WEEKLY".to_string()),
             RecurrenceType::Monthly => parts.push("FREQ=MONTHLY".to_string()),
             RecurrenceType::Yearly => parts.push("FREQ=YEARLY".to_string()),
             RecurrenceType::None => return String::new(),
         }
-        
+
         // Add interval if not 1
         if self.recurrence_interval > 1 {
             parts.push(format!("INTERVAL={}", self.recurrence_interval));
         }
-        
+
         // Add frequency-specific rules
         match self.recurrence {
             RecurrenceType::Weekly => {
                 // Add BYDAY for weekly recurrence
-                let selected_days: Vec<&str> = self.recurrence_days.iter()
+                let selected_days: Vec<&str> = self
+                    .recurrence_days
+                    .iter()
                     .enumerate()
-                    .filter_map(|(i, &selected)| if selected {
-                        Some(match i {
-                            0 => "SU", // Sunday
-                            1 => "MO", // Monday  
-                            2 => "TU", // Tuesday
-                            3 => "WE", // Wednesday
-                            4 => "TH", // Thursday
-                            5 => "FR", // Friday
-                            6 => "SA", // Saturday
-                            _ => "",
-                        })
-                    } else {
-                        None
+                    .filter_map(|(i, &selected)| {
+                        if selected {
+                            Some(match i {
+                                0 => "SU", // Sunday
+                                1 => "MO", // Monday
+                                2 => "TU", // Tuesday
+                                3 => "WE", // Wednesday
+                                4 => "TH", // Thursday
+                                5 => "FR", // Friday
+                                6 => "SA", // Saturday
+                                _ => "",
+                            })
+                        } else {
+                            None
+                        }
                     })
                     .filter(|s| !s.is_empty())
                     .collect();
-                    
+
                 if !selected_days.is_empty() {
                     parts.push(format!("BYDAY={}", selected_days.join(",")));
                 }
-            },
+            }
             RecurrenceType::Monthly => {
                 // Add BYDAY or BYMONTHDAY for monthly recurrence
                 if let Some(ref by_day) = self.monthly_by_day {
@@ -437,25 +442,29 @@ impl EventCreationData {
                 } else if let Some(by_monthday) = self.monthly_by_monthday {
                     parts.push(format!("BYMONTHDAY={}", by_monthday));
                 }
-            },
+            }
             RecurrenceType::Yearly => {
                 // Add BYMONTH for yearly recurrence
-                let selected_months: Vec<String> = self.yearly_by_month.iter()
+                let selected_months: Vec<String> = self
+                    .yearly_by_month
+                    .iter()
                     .enumerate()
-                    .filter_map(|(i, &selected)| if selected {
-                        Some((i + 1).to_string()) // Convert 0-based index to 1-based month
-                    } else {
-                        None
+                    .filter_map(|(i, &selected)| {
+                        if selected {
+                            Some((i + 1).to_string()) // Convert 0-based index to 1-based month
+                        } else {
+                            None
+                        }
                     })
                     .collect();
-                    
+
                 if !selected_months.is_empty() {
                     parts.push(format!("BYMONTH={}", selected_months.join(",")));
                 }
-            },
+            }
             _ => {}
         }
-        
+
         // Add end condition (UNTIL or COUNT)
         if let Some(until_date) = self.recurrence_until {
             // Format as UNTIL=YYYYMMDDTHHMMSSZ
@@ -463,20 +472,45 @@ impl EventCreationData {
         } else if let Some(count) = self.recurrence_count {
             parts.push(format!("COUNT={}", count));
         }
-        
+
         parts.join(";")
     }
 
-    pub fn to_create_event_params(&self) -> (String, String, String, String, String, String, String, bool, String, String, Option<u8>, String, String, String, String, String, Vec<bool>, Option<String>) {
+    pub fn to_create_event_params(
+        &self,
+    ) -> (
+        String,
+        String,
+        String,
+        String,
+        String,
+        String,
+        String,
+        bool,
+        String,
+        String,
+        Option<u8>,
+        String,
+        String,
+        String,
+        String,
+        String,
+        Vec<bool>,
+        Option<String>,
+    ) {
         // Convert local date/time to UTC
-        let start_local = Local.from_local_datetime(&self.start_date.and_time(self.start_time)).single()
+        let start_local = Local
+            .from_local_datetime(&self.start_date.and_time(self.start_time))
+            .single()
             .unwrap_or_else(|| Local::now());
-        let end_local = Local.from_local_datetime(&self.end_date.and_time(self.end_time)).single()
+        let end_local = Local
+            .from_local_datetime(&self.end_date.and_time(self.end_time))
+            .single()
             .unwrap_or_else(|| Local::now());
-        
+
         let start_utc = start_local.with_timezone(&Utc);
         let end_utc = end_local.with_timezone(&Utc);
-        
+
         (
             self.title.clone(),
             self.description.clone(),
@@ -512,7 +546,7 @@ impl EventCreationData {
             },
             self.build_rrule(), // Use the comprehensive RRULE builder
             self.recurrence_days.clone(),
-            self.selected_calendar.clone()
+            self.selected_calendar.clone(),
         )
     }
 }
@@ -522,32 +556,57 @@ impl EventCreationData {
         // Convert VEvent to EventCreationData for editing
         // All events (including temporary drag events) now have proper UTC times
         // Convert to local time for display in the modal
-        
+
         // Parse RRULE once for efficiency
         let parsed_rrule = parse_rrule(event.rrule.as_deref());
-        
+
         Self {
             title: event.summary.clone().unwrap_or_default(),
             description: event.description.clone().unwrap_or_default(),
             start_date: event.dtstart.with_timezone(&chrono::Local).date_naive(),
             start_time: event.dtstart.with_timezone(&chrono::Local).time(),
-            end_date: event.dtend.as_ref().map(|e| e.with_timezone(&chrono::Local).date_naive()).unwrap_or(event.dtstart.with_timezone(&chrono::Local).date_naive()),
-            end_time: event.dtend.as_ref().map(|e| e.with_timezone(&chrono::Local).time()).unwrap_or(event.dtstart.with_timezone(&chrono::Local).time()),
+            end_date: event
+                .dtend
+                .as_ref()
+                .map(|e| e.with_timezone(&chrono::Local).date_naive())
+                .unwrap_or(event.dtstart.with_timezone(&chrono::Local).date_naive()),
+            end_time: event
+                .dtend
+                .as_ref()
+                .map(|e| e.with_timezone(&chrono::Local).time())
+                .unwrap_or(event.dtstart.with_timezone(&chrono::Local).time()),
             location: event.location.clone().unwrap_or_default(),
             all_day: event.all_day,
-            status: event.status.as_ref().map(|s| match s {
-                crate::models::ical::EventStatus::Tentative => EventStatus::Tentative,
-                crate::models::ical::EventStatus::Confirmed => EventStatus::Confirmed,
-                crate::models::ical::EventStatus::Cancelled => EventStatus::Cancelled,
-            }).unwrap_or(EventStatus::Confirmed),
-            class: event.class.as_ref().map(|c| match c {
-                crate::models::ical::EventClass::Public => EventClass::Public,
-                crate::models::ical::EventClass::Private => EventClass::Private,
-                crate::models::ical::EventClass::Confidential => EventClass::Confidential,
-            }).unwrap_or(EventClass::Public),
+            status: event
+                .status
+                .as_ref()
+                .map(|s| match s {
+                    crate::models::ical::EventStatus::Tentative => EventStatus::Tentative,
+                    crate::models::ical::EventStatus::Confirmed => EventStatus::Confirmed,
+                    crate::models::ical::EventStatus::Cancelled => EventStatus::Cancelled,
+                })
+                .unwrap_or(EventStatus::Confirmed),
+            class: event
+                .class
+                .as_ref()
+                .map(|c| match c {
+                    crate::models::ical::EventClass::Public => EventClass::Public,
+                    crate::models::ical::EventClass::Private => EventClass::Private,
+                    crate::models::ical::EventClass::Confidential => EventClass::Confidential,
+                })
+                .unwrap_or(EventClass::Public),
             priority: event.priority,
-            organizer: event.organizer.as_ref().map(|o| o.cal_address.clone()).unwrap_or_default(),
-            attendees: event.attendees.iter().map(|a| a.cal_address.clone()).collect::<Vec<_>>().join(", "),
+            organizer: event
+                .organizer
+                .as_ref()
+                .map(|o| o.cal_address.clone())
+                .unwrap_or_default(),
+            attendees: event
+                .attendees
+                .iter()
+                .map(|a| a.cal_address.clone())
+                .collect::<Vec<_>>()
+                .join(", "),
             categories: event.categories.join(", "),
             reminder: ReminderType::default(), // TODO: Convert from event reminders
             recurrence: parsed_rrule.freq.clone(),
@@ -557,7 +616,7 @@ impl EventCreationData {
                 vec![false; 7]
             },
             selected_calendar: event.calendar_path.clone(),
-            
+
             // Advanced recurrence fields from parsed RRULE
             recurrence_interval: parsed_rrule.interval,
             recurrence_until: parsed_rrule.until,
@@ -577,13 +636,12 @@ impl EventCreationData {
             } else {
                 vec![false; 12]
             },
-            
+
             // Edit scope and tracking defaults (will be set later if needed)
             edit_scope: None,
             changed_fields: vec![],
         }
     }
-
 }
 
 #[derive(Clone, PartialEq)]
@@ -606,51 +664,70 @@ impl Default for ModalTab {
 pub fn create_event_modal(props: &CreateEventModalProps) -> Html {
     let event_data = use_state(|| EventCreationData::default());
     let active_tab = use_state(|| ModalTab::default());
-    
+
     // Initialize with selected date or event data if provided
-    use_effect_with((props.selected_date, props.event_to_edit.clone(), props.is_open, props.available_calendars.clone(), props.initial_start_time, props.initial_end_time, props.edit_scope.clone()), {
-        let event_data = event_data.clone();
-        move |(selected_date, event_to_edit, is_open, available_calendars, initial_start_time, initial_end_time, edit_scope)| {
-            if *is_open {
-                let mut data = if let Some(event) = event_to_edit {
-                    // Pre-populate with event data for editing
-                    EventCreationData::from_calendar_event(event)
-                } else if let Some(date) = selected_date {
-                    // Initialize with selected date for new event
-                    let mut data = EventCreationData::default();
-                    data.start_date = *date;
-                    data.end_date = *date;
-                    
-                    // Use initial times if provided (from drag-to-create)
-                    if let Some(start_time) = initial_start_time {
-                        data.start_time = *start_time;
+    use_effect_with(
+        (
+            props.selected_date,
+            props.event_to_edit.clone(),
+            props.is_open,
+            props.available_calendars.clone(),
+            props.initial_start_time,
+            props.initial_end_time,
+            props.edit_scope.clone(),
+        ),
+        {
+            let event_data = event_data.clone();
+            move |(
+                selected_date,
+                event_to_edit,
+                is_open,
+                available_calendars,
+                initial_start_time,
+                initial_end_time,
+                edit_scope,
+            )| {
+                if *is_open {
+                    let mut data = if let Some(event) = event_to_edit {
+                        // Pre-populate with event data for editing
+                        EventCreationData::from_calendar_event(event)
+                    } else if let Some(date) = selected_date {
+                        // Initialize with selected date for new event
+                        let mut data = EventCreationData::default();
+                        data.start_date = *date;
+                        data.end_date = *date;
+
+                        // Use initial times if provided (from drag-to-create)
+                        if let Some(start_time) = initial_start_time {
+                            data.start_time = *start_time;
+                        }
+                        if let Some(end_time) = initial_end_time {
+                            data.end_time = *end_time;
+                        }
+
+                        data
+                    } else {
+                        // Default initialization
+                        EventCreationData::default()
+                    };
+
+                    // Set default calendar to the first available one if none selected
+                    if data.selected_calendar.is_none() && !available_calendars.is_empty() {
+                        data.selected_calendar = Some(available_calendars[0].path.clone());
                     }
-                    if let Some(end_time) = initial_end_time {
-                        data.end_time = *end_time;
+
+                    // Set edit scope if provided
+                    if let Some(scope) = edit_scope {
+                        data.edit_scope = Some(scope.clone());
                     }
-                    
-                    data
-                } else {
-                    // Default initialization
-                    EventCreationData::default()
-                };
-                
-                // Set default calendar to the first available one if none selected
-                if data.selected_calendar.is_none() && !available_calendars.is_empty() {
-                    data.selected_calendar = Some(available_calendars[0].path.clone());
+
+                    event_data.set(data);
                 }
-                
-                // Set edit scope if provided
-                if let Some(scope) = edit_scope {
-                    data.edit_scope = Some(scope.clone());
-                }
-                
-                event_data.set(data);
+                || ()
             }
-            || ()
-        }
-    });
-    
+        },
+    );
+
     if !props.is_open {
         return html! {};
     }
@@ -697,7 +774,10 @@ pub fn create_event_modal(props: &CreateEventModalProps) -> Html {
                 let new_calendar = if value.is_empty() { None } else { Some(value) };
                 if data.selected_calendar != new_calendar {
                     data.selected_calendar = new_calendar;
-                    if !data.changed_fields.contains(&"selected_calendar".to_string()) {
+                    if !data
+                        .changed_fields
+                        .contains(&"selected_calendar".to_string())
+                    {
                         data.changed_fields.push("selected_calendar".to_string());
                     }
                 }
@@ -1062,11 +1142,11 @@ pub fn create_event_modal(props: &CreateEventModalProps) -> Html {
                         move |_: MouseEvent| on_close.emit(())
                     })}>{"×"}</button>
                 </div>
-                
+
                 <div class="modal-body">
                     // Tab navigation
                     <div class="tab-navigation">
-                        <button 
+                        <button
                             type="button"
                             class={if *active_tab == ModalTab::BasicDetails { "tab-button active" } else { "tab-button" }}
                             onclick={
@@ -1076,7 +1156,7 @@ pub fn create_event_modal(props: &CreateEventModalProps) -> Html {
                         >
                             {"Basic Details"}
                         </button>
-                        <button 
+                        <button
                             type="button"
                             class={if *active_tab == ModalTab::Advanced { "tab-button active" } else { "tab-button" }}
                             onclick={
@@ -1086,7 +1166,7 @@ pub fn create_event_modal(props: &CreateEventModalProps) -> Html {
                         >
                             {"Advanced"}
                         </button>
-                        <button 
+                        <button
                             type="button"
                             class={if *active_tab == ModalTab::People { "tab-button active" } else { "tab-button" }}
                             onclick={
@@ -1096,7 +1176,7 @@ pub fn create_event_modal(props: &CreateEventModalProps) -> Html {
                         >
                             {"People"}
                         </button>
-                        <button 
+                        <button
                             type="button"
                             class={if *active_tab == ModalTab::Categories { "tab-button active" } else { "tab-button" }}
                             onclick={
@@ -1106,7 +1186,7 @@ pub fn create_event_modal(props: &CreateEventModalProps) -> Html {
                         >
                             {"Categories"}
                         </button>
-                        <button 
+                        <button
                             type="button"
                             class={if *active_tab == ModalTab::Location { "tab-button active" } else { "tab-button" }}
                             onclick={
@@ -1116,7 +1196,7 @@ pub fn create_event_modal(props: &CreateEventModalProps) -> Html {
                         >
                             {"Location"}
                         </button>
-                        <button 
+                        <button
                             type="button"
                             class={if *active_tab == ModalTab::Reminders { "tab-button active" } else { "tab-button" }}
                             onclick={
@@ -1128,7 +1208,7 @@ pub fn create_event_modal(props: &CreateEventModalProps) -> Html {
                         </button>
                     </div>
                 </div>
-                
+
                 // Tab Content
                 <div class="tab-content">
                     {
@@ -1137,10 +1217,10 @@ pub fn create_event_modal(props: &CreateEventModalProps) -> Html {
                                 <div class="tab-panel">
                                     <div class="form-group">
                                         <label for="event-title">{"Title *"}</label>
-                                        <input 
-                                            type="text" 
+                                        <input
+                                            type="text"
                                             id="event-title"
-                                            class="form-input" 
+                                            class="form-input"
                                             value={data.title.clone()}
                                             oninput={on_title_input}
                                             placeholder="Enter event title"
@@ -1150,9 +1230,9 @@ pub fn create_event_modal(props: &CreateEventModalProps) -> Html {
 
                                     <div class="form-group">
                                         <label for="event-calendar">{"Calendar"}</label>
-                                        <select 
+                                        <select
                                             id="event-calendar"
-                                            class="form-input" 
+                                            class="form-input"
                                             onchange={on_calendar_change}
                                         >
                                             <option value="" selected={data.selected_calendar.is_none()}>{"Select calendar..."}</option>
@@ -1160,8 +1240,8 @@ pub fn create_event_modal(props: &CreateEventModalProps) -> Html {
                                                 props.available_calendars.iter().map(|calendar| {
                                                     let is_selected = data.selected_calendar.as_ref() == Some(&calendar.path);
                                                     html! {
-                                                        <option 
-                                                            key={calendar.path.clone()} 
+                                                        <option
+                                                            key={calendar.path.clone()}
                                                             value={calendar.path.clone()}
                                                             selected={is_selected}
                                                         >
@@ -1175,9 +1255,9 @@ pub fn create_event_modal(props: &CreateEventModalProps) -> Html {
 
                                     <div class="form-group">
                                         <label for="event-description">{"Description"}</label>
-                                        <textarea 
+                                        <textarea
                                             id="event-description"
-                                            class="form-input" 
+                                            class="form-input"
                                             value={data.description.clone()}
                                             oninput={on_description_input}
                                             placeholder="Enter event description"
@@ -1187,8 +1267,8 @@ pub fn create_event_modal(props: &CreateEventModalProps) -> Html {
 
                                     <div class="form-group">
                                         <label>
-                                            <input 
-                                                type="checkbox" 
+                                            <input
+                                                type="checkbox"
                                                 checked={data.all_day}
                                                 onchange={on_all_day_change}
                                             />
@@ -1199,9 +1279,9 @@ pub fn create_event_modal(props: &CreateEventModalProps) -> Html {
                                     <div class="form-row">
                                         <div class="form-group">
                                             <label for="event-recurrence-basic">{"Repeat"}</label>
-                                            <select 
+                                            <select
                                                 id="event-recurrence-basic"
-                                                class="form-input" 
+                                                class="form-input"
                                                 onchange={on_recurrence_change}
                                             >
                                                 <option value="none" selected={matches!(data.recurrence, RecurrenceType::None)}>{"Does not repeat"}</option>
@@ -1214,9 +1294,9 @@ pub fn create_event_modal(props: &CreateEventModalProps) -> Html {
 
                                         <div class="form-group">
                                             <label for="event-reminder-basic">{"Reminder"}</label>
-                                            <select 
+                                            <select
                                                 id="event-reminder-basic"
-                                                class="form-input" 
+                                                class="form-input"
                                                 onchange={on_reminder_change}
                                             >
                                                 <option value="none" selected={matches!(data.reminder, ReminderType::None)}>{"None"}</option>
@@ -1231,23 +1311,23 @@ pub fn create_event_modal(props: &CreateEventModalProps) -> Html {
                                     <div class="form-row">
                                         <div class="form-group">
                                             <label for="start-date">{"Start Date *"}</label>
-                                            <input 
-                                                type="date" 
+                                            <input
+                                                type="date"
                                                 id="start-date"
-                                                class="form-input" 
+                                                class="form-input"
                                                 value={data.start_date.format("%Y-%m-%d").to_string()}
                                                 onchange={on_start_date_change}
                                                 required=true
                                             />
                                         </div>
-                                        
+
                                         if !data.all_day {
                                             <div class="form-group">
                                                 <label for="start-time">{"Start Time"}</label>
-                                                <input 
-                                                    type="time" 
+                                                <input
+                                                    type="time"
                                                     id="start-time"
-                                                    class="form-input" 
+                                                    class="form-input"
                                                     value={data.start_time.format("%H:%M").to_string()}
                                                     onchange={on_start_time_change}
                                                 />
@@ -1258,23 +1338,23 @@ pub fn create_event_modal(props: &CreateEventModalProps) -> Html {
                                     <div class="form-row">
                                         <div class="form-group">
                                             <label for="end-date">{"End Date *"}</label>
-                                            <input 
-                                                type="date" 
+                                            <input
+                                                type="date"
                                                 id="end-date"
-                                                class="form-input" 
+                                                class="form-input"
                                                 value={data.end_date.format("%Y-%m-%d").to_string()}
                                                 onchange={on_end_date_change}
                                                 required=true
                                             />
                                         </div>
-                                        
+
                                         if !data.all_day {
                                             <div class="form-group">
                                                 <label for="end-time">{"End Time"}</label>
-                                                <input 
-                                                    type="time" 
+                                                <input
+                                                    type="time"
                                                     id="end-time"
-                                                    class="form-input" 
+                                                    class="form-input"
                                                     value={data.end_time.format("%H:%M").to_string()}
                                                     onchange={on_end_time_change}
                                                 />
@@ -1284,10 +1364,10 @@ pub fn create_event_modal(props: &CreateEventModalProps) -> Html {
 
                                     <div class="form-group">
                                         <label for="event-location">{"Location"}</label>
-                                        <input 
-                                            type="text" 
+                                        <input
+                                            type="text"
                                             id="event-location"
-                                            class="form-input" 
+                                            class="form-input"
                                             value={data.location.clone()}
                                             oninput={on_location_input}
                                             placeholder="Enter event location"
@@ -1308,8 +1388,8 @@ pub fn create_event_modal(props: &CreateEventModalProps) -> Html {
                                                             let on_change = on_weekday_change(i);
                                                             html! {
                                                                 <label key={i} class="weekday-checkbox">
-                                                                    <input 
-                                                                        type="checkbox" 
+                                                                    <input
+                                                                        type="checkbox"
                                                                         checked={day_checked}
                                                                         onchange={on_change}
                                                                     />
@@ -1330,7 +1410,7 @@ pub fn create_event_modal(props: &CreateEventModalProps) -> Html {
                                                 <div class="form-group">
                                                     <label for="recurrence-interval">{"Every"}</label>
                                                     <div class="interval-input">
-                                                        <input 
+                                                        <input
                                                             id="recurrence-interval"
                                                             type="number"
                                                             class="form-input"
@@ -1356,9 +1436,9 @@ pub fn create_event_modal(props: &CreateEventModalProps) -> Html {
                                                     <div class="end-options">
                                                         <div class="end-option">
                                                             <label class="radio-label">
-                                                                <input 
-                                                                    type="radio" 
-                                                                    name="recurrence-end" 
+                                                                <input
+                                                                    type="radio"
+                                                                    name="recurrence-end"
                                                                     value="never"
                                                                     checked={data.recurrence_until.is_none() && data.recurrence_count.is_none()}
                                                                     onchange={{
@@ -1374,12 +1454,12 @@ pub fn create_event_modal(props: &CreateEventModalProps) -> Html {
                                                                 {"Never"}
                                                             </label>
                                                         </div>
-                                                        
+
                                                         <div class="end-option">
                                                             <label class="radio-label">
-                                                                <input 
-                                                                    type="radio" 
-                                                                    name="recurrence-end" 
+                                                                <input
+                                                                    type="radio"
+                                                                    name="recurrence-end"
                                                                     value="until"
                                                                     checked={data.recurrence_until.is_some()}
                                                                     onchange={{
@@ -1394,19 +1474,19 @@ pub fn create_event_modal(props: &CreateEventModalProps) -> Html {
                                                                 />
                                                                 {"Until"}
                                                             </label>
-                                                            <input 
+                                                            <input
                                                                 type="date"
                                                                 class="form-input"
                                                                 value={data.recurrence_until.map(|d| d.format("%Y-%m-%d").to_string()).unwrap_or_default()}
                                                                 onchange={on_recurrence_until_change.clone()}
                                                             />
                                                         </div>
-                                                        
+
                                                         <div class="end-option">
                                                             <label class="radio-label">
-                                                                <input 
-                                                                    type="radio" 
-                                                                    name="recurrence-end" 
+                                                                <input
+                                                                    type="radio"
+                                                                    name="recurrence-end"
                                                                     value="count"
                                                                     checked={data.recurrence_count.is_some()}
                                                                     onchange={{
@@ -1421,7 +1501,7 @@ pub fn create_event_modal(props: &CreateEventModalProps) -> Html {
                                                                 />
                                                                 {"After"}
                                                             </label>
-                                                            <input 
+                                                            <input
                                                                 type="number"
                                                                 class="form-input count-input"
                                                                 value={data.recurrence_count.map(|c| c.to_string()).unwrap_or_default()}
@@ -1443,9 +1523,9 @@ pub fn create_event_modal(props: &CreateEventModalProps) -> Html {
                                                     <div class="monthly-options">
                                                         <div class="monthly-option">
                                                             <label class="radio-label">
-                                                                <input 
-                                                                    type="radio" 
-                                                                    name="monthly-type" 
+                                                                <input
+                                                                    type="radio"
+                                                                    name="monthly-type"
                                                                     checked={data.monthly_by_monthday.is_some()}
                                                                     onchange={{
                                                                         let event_data = event_data.clone();
@@ -1459,7 +1539,7 @@ pub fn create_event_modal(props: &CreateEventModalProps) -> Html {
                                                                 />
                                                                 {"Day of month:"}
                                                             </label>
-                                                            <input 
+                                                            <input
                                                                 type="number"
                                                                 class="form-input day-input"
                                                                 value={data.monthly_by_monthday.map(|d| d.to_string()).unwrap_or_else(|| data.start_date.day().to_string())}
@@ -1468,12 +1548,12 @@ pub fn create_event_modal(props: &CreateEventModalProps) -> Html {
                                                                 onchange={on_monthly_by_monthday_change.clone()}
                                                             />
                                                         </div>
-                                                        
+
                                                         <div class="monthly-option">
                                                             <label class="radio-label">
-                                                                <input 
-                                                                    type="radio" 
-                                                                    name="monthly-type" 
+                                                                <input
+                                                                    type="radio"
+                                                                    name="monthly-type"
                                                                     checked={data.monthly_by_day.is_some()}
                                                                     onchange={{
                                                                         let event_data = event_data.clone();
@@ -1487,7 +1567,7 @@ pub fn create_event_modal(props: &CreateEventModalProps) -> Html {
                                                                 />
                                                                 {"Day of week:"}
                                                             </label>
-                                                            <select 
+                                                            <select
                                                                 class="form-input"
                                                                 value={data.monthly_by_day.clone().unwrap_or_default()}
                                                                 onchange={on_monthly_by_day_change.clone()}
@@ -1540,7 +1620,7 @@ pub fn create_event_modal(props: &CreateEventModalProps) -> Html {
                                                     <label>{"Repeat in months"}</label>
                                                     <div class="yearly-months">
                                                         {
-                                                            ["Jan", "Feb", "Mar", "Apr", "May", "Jun", 
+                                                            ["Jan", "Feb", "Mar", "Apr", "May", "Jun",
                                                              "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"]
                                                                 .iter()
                                                                 .enumerate()
@@ -1549,8 +1629,8 @@ pub fn create_event_modal(props: &CreateEventModalProps) -> Html {
                                                                     let on_change = on_yearly_month_change(i);
                                                                     html! {
                                                                         <label key={i} class="month-checkbox">
-                                                                            <input 
-                                                                                type="checkbox" 
+                                                                            <input
+                                                                                type="checkbox"
                                                                                 checked={month_checked}
                                                                                 onchange={on_change}
                                                                             />
@@ -1572,9 +1652,9 @@ pub fn create_event_modal(props: &CreateEventModalProps) -> Html {
                                     <div class="form-row">
                                         <div class="form-group">
                                             <label for="event-status">{"Status"}</label>
-                                            <select 
+                                            <select
                                                 id="event-status"
-                                                class="form-input" 
+                                                class="form-input"
                                                 onchange={on_status_change}
                                             >
                                                 <option value="confirmed" selected={matches!(data.status, EventStatus::Confirmed)}>{"Confirmed"}</option>
@@ -1582,12 +1662,12 @@ pub fn create_event_modal(props: &CreateEventModalProps) -> Html {
                                                 <option value="cancelled" selected={matches!(data.status, EventStatus::Cancelled)}>{"Cancelled"}</option>
                                             </select>
                                         </div>
-                                        
+
                                         <div class="form-group">
                                             <label for="event-class">{"Privacy"}</label>
-                                            <select 
+                                            <select
                                                 id="event-class"
-                                                class="form-input" 
+                                                class="form-input"
                                                 onchange={on_class_change}
                                             >
                                                 <option value="public" selected={matches!(data.class, EventClass::Public)}>{"Public"}</option>
@@ -1599,9 +1679,9 @@ pub fn create_event_modal(props: &CreateEventModalProps) -> Html {
 
                                     <div class="form-group">
                                         <label for="event-priority">{"Priority"}</label>
-                                        <select 
+                                        <select
                                             id="event-priority"
-                                            class="form-input" 
+                                            class="form-input"
                                             onchange={
                                                 let event_data = event_data.clone();
                                                 Callback::from(move |e: Event| {
@@ -1609,10 +1689,10 @@ pub fn create_event_modal(props: &CreateEventModalProps) -> Html {
                                                         if let Ok(select) = target.dyn_into::<HtmlSelectElement>() {
                                                             let mut data = (*event_data).clone();
                                                             let value = select.value();
-                                                            data.priority = if value.is_empty() { 
-                                                                None 
-                                                            } else { 
-                                                                value.parse::<u8>().ok().filter(|&p| p <= 9) 
+                                                            data.priority = if value.is_empty() {
+                                                                None
+                                                            } else {
+                                                                value.parse::<u8>().ok().filter(|&p| p <= 9)
                                                             };
                                                             event_data.set(data);
                                                         }
@@ -1636,9 +1716,9 @@ pub fn create_event_modal(props: &CreateEventModalProps) -> Html {
 
                                     <div class="form-group">
                                         <label for="advanced-reminder">{"Advanced Reminder Options"}</label>
-                                        <select 
+                                        <select
                                             id="advanced-reminder"
-                                            class="form-input" 
+                                            class="form-input"
                                             onchange={on_reminder_change}
                                         >
                                             <option value="none" selected={matches!(data.reminder, ReminderType::None)}>{"None"}</option>
@@ -1655,9 +1735,9 @@ pub fn create_event_modal(props: &CreateEventModalProps) -> Html {
 
                                     <div class="form-group">
                                         <label for="advanced-recurrence">{"Advanced Recurrence"}</label>
-                                        <select 
+                                        <select
                                             id="advanced-recurrence"
-                                            class="form-input" 
+                                            class="form-input"
                                             onchange={on_recurrence_change}
                                         >
                                             <option value="none" selected={matches!(data.recurrence, RecurrenceType::None)}>{"Does not repeat"}</option>
@@ -1683,8 +1763,8 @@ pub fn create_event_modal(props: &CreateEventModalProps) -> Html {
                                                             let on_change = on_weekday_change(i);
                                                             html! {
                                                                 <label key={i} class="weekday-checkbox">
-                                                                    <input 
-                                                                        type="checkbox" 
+                                                                    <input
+                                                                        type="checkbox"
                                                                         checked={day_checked}
                                                                         onchange={on_change}
                                                                     />
@@ -1715,10 +1795,10 @@ pub fn create_event_modal(props: &CreateEventModalProps) -> Html {
                                 <div class="tab-panel">
                                     <div class="form-group">
                                         <label for="event-organizer">{"Organizer"}</label>
-                                        <input 
-                                            type="email" 
+                                        <input
+                                            type="email"
                                             id="event-organizer"
-                                            class="form-input" 
+                                            class="form-input"
                                             value={data.organizer.clone()}
                                             oninput={on_organizer_input}
                                             placeholder="organizer@example.com"
@@ -1728,9 +1808,9 @@ pub fn create_event_modal(props: &CreateEventModalProps) -> Html {
 
                                     <div class="form-group">
                                         <label for="event-attendees">{"Attendees"}</label>
-                                        <textarea 
+                                        <textarea
                                             id="event-attendees"
-                                            class="form-input" 
+                                            class="form-input"
                                             value={data.attendees.clone()}
                                             oninput={on_attendees_input}
                                             placeholder="attendee1@example.com, attendee2@example.com, attendee3@example.com"
@@ -1747,7 +1827,7 @@ pub fn create_event_modal(props: &CreateEventModalProps) -> Html {
                                             <li>{"Response tracking follows RFC 5545 PARTSTAT standards"}</li>
                                             <li>{"Delegation and role management available after event creation"}</li>
                                         </ul>
-                                        
+
                                         <div class="people-validation">
                                             <h6>{"Email Validation"}</h6>
                                             <p>{"Email addresses will be validated when you save the event. Invalid emails will be highlighted and must be corrected before proceeding."}</p>
@@ -1758,19 +1838,19 @@ pub fn create_event_modal(props: &CreateEventModalProps) -> Html {
                                         <h5>{"Advanced Attendee Features"}</h5>
                                         <div class="role-examples">
                                             <div class="role-item">
-                                                <strong>{"Chair:"}</strong> 
+                                                <strong>{"Chair:"}</strong>
                                                 <span>{"Meeting leader or event host"}</span>
                                             </div>
                                             <div class="role-item">
-                                                <strong>{"Required Participant:"}</strong> 
+                                                <strong>{"Required Participant:"}</strong>
                                                 <span>{"Attendance is required"}</span>
                                             </div>
                                             <div class="role-item">
-                                                <strong>{"Optional Participant:"}</strong> 
+                                                <strong>{"Optional Participant:"}</strong>
                                                 <span>{"Attendance is optional"}</span>
                                             </div>
                                             <div class="role-item">
-                                                <strong>{"Non-Participant:"}</strong> 
+                                                <strong>{"Non-Participant:"}</strong>
                                                 <span>{"For information only"}</span>
                                             </div>
                                         </div>
@@ -1782,10 +1862,10 @@ pub fn create_event_modal(props: &CreateEventModalProps) -> Html {
                                 <div class="tab-panel">
                                     <div class="form-group">
                                         <label for="event-categories">{"Categories"}</label>
-                                        <input 
-                                            type="text" 
+                                        <input
+                                            type="text"
                                             id="event-categories"
-                                            class="form-input" 
+                                            class="form-input"
                                             value={data.categories.clone()}
                                             oninput={on_categories_input}
                                             placeholder="work, meeting, personal, project, urgent"
@@ -1880,25 +1960,25 @@ pub fn create_event_modal(props: &CreateEventModalProps) -> Html {
                                             <li>{"Categories are searchable and can be used for reporting"}</li>
                                             <li>{"Multiple categories per event are fully supported"}</li>
                                         </ul>
-                                        
+
                                         <div class="resources-section">
                                             <h6>{"Resources & Related Events"}</h6>
                                             <p>{"Advanced resource management features will include:"}</p>
                                             <div class="resource-features">
                                                 <div class="feature-item">
-                                                    <strong>{"Equipment Resources:"}</strong> 
+                                                    <strong>{"Equipment Resources:"}</strong>
                                                     <span>{"Projectors, rooms, vehicles"}</span>
                                                 </div>
                                                 <div class="feature-item">
-                                                    <strong>{"Human Resources:"}</strong> 
+                                                    <strong>{"Human Resources:"}</strong>
                                                     <span>{"Required staff, specialists"}</span>
                                                 </div>
                                                 <div class="feature-item">
-                                                    <strong>{"Related Events:"}</strong> 
+                                                    <strong>{"Related Events:"}</strong>
                                                     <span>{"Link dependencies and sequences"}</span>
                                                 </div>
                                                 <div class="feature-item">
-                                                    <strong>{"Comments & Notes:"}</strong> 
+                                                    <strong>{"Comments & Notes:"}</strong>
                                                     <span>{"Internal notes and documentation"}</span>
                                                 </div>
                                             </div>
@@ -1925,10 +2005,10 @@ pub fn create_event_modal(props: &CreateEventModalProps) -> Html {
                                 <div class="tab-panel">
                                     <div class="form-group">
                                         <label for="event-location-detailed">{"Event Location"}</label>
-                                        <input 
-                                            type="text" 
+                                        <input
+                                            type="text"
                                             id="event-location-detailed"
-                                            class="form-input" 
+                                            class="form-input"
                                             value={data.location.clone()}
                                             oninput={on_location_input}
                                             placeholder="Conference Room A, 123 Main St, City, State 12345"
@@ -1991,25 +2071,25 @@ pub fn create_event_modal(props: &CreateEventModalProps) -> Html {
                                             <li>{"Compatible with mapping and navigation applications"}</li>
                                             <li>{"Room booking integration available for enterprise setups"}</li>
                                         </ul>
-                                        
+
                                         <div class="geo-section">
                                             <h6>{"Geographic Coordinates (Advanced)"}</h6>
                                             <p>{"Future versions will support:"}</p>
                                             <div class="geo-features">
                                                 <div class="geo-item">
-                                                    <strong>{"GPS Coordinates:"}</strong> 
+                                                    <strong>{"GPS Coordinates:"}</strong>
                                                     <span>{"Precise latitude/longitude positioning"}</span>
                                                 </div>
                                                 <div class="geo-item">
-                                                    <strong>{"Map Integration:"}</strong> 
+                                                    <strong>{"Map Integration:"}</strong>
                                                     <span>{"Embedded maps in event details"}</span>
                                                 </div>
                                                 <div class="geo-item">
-                                                    <strong>{"Travel Time:"}</strong> 
+                                                    <strong>{"Travel Time:"}</strong>
                                                     <span>{"Automatic travel time calculation"}</span>
                                                 </div>
                                                 <div class="geo-item">
-                                                    <strong>{"Location History:"}</strong> 
+                                                    <strong>{"Location History:"}</strong>
                                                     <span>{"Smart suggestions based on past events"}</span>
                                                 </div>
                                             </div>
@@ -2059,9 +2139,9 @@ pub fn create_event_modal(props: &CreateEventModalProps) -> Html {
                                 <div class="tab-panel">
                                     <div class="form-group">
                                         <label for="event-reminder-main">{"Primary Reminder"}</label>
-                                        <select 
+                                        <select
                                             id="event-reminder-main"
-                                            class="form-input" 
+                                            class="form-input"
                                             onchange={on_reminder_change}
                                         >
                                             <option value="none" selected={matches!(data.reminder, ReminderType::None)}>{"No reminder"}</option>
@@ -2108,25 +2188,25 @@ pub fn create_event_modal(props: &CreateEventModalProps) -> Html {
                                             <li>{"Snooze and dismiss functionality"}</li>
                                             <li>{"Integration with system notifications"}</li>
                                         </ul>
-                                        
+
                                         <div class="attachments-section">
                                             <h6>{"File Attachments & Documents"}</h6>
                                             <p>{"Future attachment features will include:"}</p>
                                             <div class="attachment-features">
                                                 <div class="attachment-type">
-                                                    <strong>{"File Uploads:"}</strong> 
+                                                    <strong>{"File Uploads:"}</strong>
                                                     <span>{"Documents, images, presentations"}</span>
                                                 </div>
                                                 <div class="attachment-type">
-                                                    <strong>{"URL Links:"}</strong> 
+                                                    <strong>{"URL Links:"}</strong>
                                                     <span>{"Web resources and reference materials"}</span>
                                                 </div>
                                                 <div class="attachment-type">
-                                                    <strong>{"Cloud Storage:"}</strong> 
+                                                    <strong>{"Cloud Storage:"}</strong>
                                                     <span>{"Google Drive, Dropbox, OneDrive integration"}</span>
                                                 </div>
                                                 <div class="attachment-type">
-                                                    <strong>{"Meeting Notes:"}</strong> 
+                                                    <strong>{"Meeting Notes:"}</strong>
                                                     <span>{"Collaborative note-taking and agenda items"}</span>
                                                 </div>
                                             </div>
@@ -2182,7 +2262,7 @@ pub fn create_event_modal(props: &CreateEventModalProps) -> Html {
                                     <div class="completion-status">
                                         <h5>{"Modal Complete!"}</h5>
                                         <p>{"You've reached the final tab of the comprehensive event creation interface. This modal now provides access to all major VEvent properties following RFC 5545 standards."}</p>
-                                        
+
                                         <div class="feature-summary">
                                             <div class="summary-row">
                                                 <span class="tab-name">{"Basic Details"}</span>
@@ -2215,14 +2295,14 @@ pub fn create_event_modal(props: &CreateEventModalProps) -> Html {
                         }
                     }
                 </div>
-                
+
                 <div class="modal-footer">
                     <button type="button" class="btn btn-secondary" onclick={on_cancel_click}>
                         {"Cancel"}
                     </button>
-                    <button 
-                        type="button" 
-                        class="btn btn-primary" 
+                    <button
+                        type="button"
+                        class="btn btn-primary"
                         onclick={on_submit_click}
                         disabled={data.title.trim().is_empty()}
                     >
@@ -2232,4 +2312,4 @@ pub fn create_event_modal(props: &CreateEventModalProps) -> Html {
             </div>
         </div>
     }
-}
\ No newline at end of file
+}
diff --git a/frontend/src/components/event_context_menu.rs b/frontend/src/components/event_context_menu.rs
index 161f91a..c5c4b3e 100644
--- a/frontend/src/components/event_context_menu.rs
+++ b/frontend/src/components/event_context_menu.rs
@@ -1,6 +1,6 @@
-use yew::prelude::*;
-use web_sys::MouseEvent;
 use crate::models::ical::VEvent;
+use web_sys::MouseEvent;
+use yew::prelude::*;
 
 #[derive(Clone, PartialEq, Debug)]
 pub enum DeleteAction {
@@ -30,7 +30,7 @@ pub struct EventContextMenuProps {
 #[function_component(EventContextMenu)]
 pub fn event_context_menu(props: &EventContextMenuProps) -> Html {
     let menu_ref = use_node_ref();
-    
+
     if !props.is_open {
         return html! {};
     }
@@ -41,7 +41,9 @@ pub fn event_context_menu(props: &EventContextMenuProps) -> Html {
     );
 
     // Check if the event is recurring
-    let is_recurring = props.event.as_ref()
+    let is_recurring = props
+        .event
+        .as_ref()
         .map(|event| event.rrule.is_some())
         .unwrap_or(false);
 
@@ -64,9 +66,9 @@ pub fn event_context_menu(props: &EventContextMenuProps) -> Html {
     };
 
     html! {
-        <div 
+        <div
             ref={menu_ref}
-            class="context-menu" 
+            class="context-menu"
             style={style}
         >
             {
@@ -117,4 +119,4 @@ pub fn event_context_menu(props: &EventContextMenuProps) -> Html {
             }
         </div>
     }
-}
\ No newline at end of file
+}
diff --git a/frontend/src/components/event_modal.rs b/frontend/src/components/event_modal.rs
index d206800..941c249 100644
--- a/frontend/src/components/event_modal.rs
+++ b/frontend/src/components/event_modal.rs
@@ -1,6 +1,6 @@
-use yew::prelude::*;
-use chrono::{DateTime, Utc};
 use crate::models::ical::VEvent;
+use chrono::{DateTime, Utc};
+use yew::prelude::*;
 
 #[derive(Properties, PartialEq)]
 pub struct EventModalProps {
@@ -16,7 +16,7 @@ pub fn EventModal(props: &EventModalProps) -> Html {
             on_close.emit(());
         })
     };
-    
+
     let backdrop_click = {
         let on_close = props.on_close.clone();
         Callback::from(move |e: MouseEvent| {
@@ -39,7 +39,7 @@ pub fn EventModal(props: &EventModalProps) -> Html {
                             <strong>{"Title:"}</strong>
                             <span>{event.get_title()}</span>
                         </div>
-                        
+
                         {
                             if let Some(ref description) = event.description {
                                 html! {
@@ -52,12 +52,12 @@ pub fn EventModal(props: &EventModalProps) -> Html {
                                 html! {}
                             }
                         }
-                        
+
                         <div class="event-detail">
                             <strong>{"Start:"}</strong>
                             <span>{format_datetime(&event.dtstart, event.all_day)}</span>
                         </div>
-                        
+
                         {
                             if let Some(ref end) = event.dtend {
                                 html! {
@@ -70,12 +70,12 @@ pub fn EventModal(props: &EventModalProps) -> Html {
                                 html! {}
                             }
                         }
-                        
+
                         <div class="event-detail">
                             <strong>{"All Day:"}</strong>
                             <span>{if event.all_day { "Yes" } else { "No" }}</span>
                         </div>
-                        
+
                         {
                             if let Some(ref location) = event.location {
                                 html! {
@@ -88,22 +88,22 @@ pub fn EventModal(props: &EventModalProps) -> Html {
                                 html! {}
                             }
                         }
-                        
+
                         <div class="event-detail">
                             <strong>{"Status:"}</strong>
                             <span>{event.get_status_display()}</span>
                         </div>
-                        
+
                         <div class="event-detail">
                             <strong>{"Privacy:"}</strong>
                             <span>{event.get_class_display()}</span>
                         </div>
-                        
+
                         <div class="event-detail">
                             <strong>{"Priority:"}</strong>
                             <span>{event.get_priority_display()}</span>
                         </div>
-                        
+
                         {
                             if let Some(ref organizer) = event.organizer {
                                 html! {
@@ -116,7 +116,7 @@ pub fn EventModal(props: &EventModalProps) -> Html {
                                 html! {}
                             }
                         }
-                        
+
                         {
                             if !event.attendees.is_empty() {
                                 html! {
@@ -129,7 +129,7 @@ pub fn EventModal(props: &EventModalProps) -> Html {
                                 html! {}
                             }
                         }
-                        
+
                         {
                             if !event.categories.is_empty() {
                                 html! {
@@ -142,7 +142,7 @@ pub fn EventModal(props: &EventModalProps) -> Html {
                                 html! {}
                             }
                         }
-                        
+
                         {
                             if let Some(ref recurrence) = event.rrule {
                                 html! {
@@ -160,7 +160,7 @@ pub fn EventModal(props: &EventModalProps) -> Html {
                                 }
                             }
                         }
-                        
+
                         {
                             if !event.alarms.is_empty() {
                                 html! {
@@ -178,7 +178,7 @@ pub fn EventModal(props: &EventModalProps) -> Html {
                                 }
                             }
                         }
-                        
+
                         {
                             if let Some(ref created) = event.created {
                                 html! {
@@ -191,7 +191,7 @@ pub fn EventModal(props: &EventModalProps) -> Html {
                                 html! {}
                             }
                         }
-                        
+
                         {
                             if let Some(ref modified) = event.last_modified {
                                 html! {
@@ -236,4 +236,3 @@ fn format_recurrence_rule(rrule: &str) -> String {
         format!("Custom ({})", rrule)
     }
 }
-
diff --git a/frontend/src/components/login.rs b/frontend/src/components/login.rs
index ec2735a..c625813 100644
--- a/frontend/src/components/login.rs
+++ b/frontend/src/components/login.rs
@@ -1,6 +1,6 @@
-use yew::prelude::*;
-use web_sys::HtmlInputElement;
 use gloo_storage::{LocalStorage, Storage};
+use web_sys::HtmlInputElement;
+use yew::prelude::*;
 
 #[derive(Properties, PartialEq)]
 pub struct LoginProps {
@@ -53,7 +53,7 @@ pub fn Login(props: &LoginProps) -> Html {
 
         Callback::from(move |e: SubmitEvent| {
             e.prevent_default();
-            
+
             let server_url = (*server_url).clone();
             let username = (*username).clone();
             let password = (*password).clone();
@@ -77,7 +77,8 @@ pub fn Login(props: &LoginProps) -> Html {
                         web_sys::console::log_1(&"✅ Login successful!".into());
                         // Store token and credentials in local storage
                         if let Err(_) = LocalStorage::set("auth_token", &token) {
-                            error_message.set(Some("Failed to store authentication token".to_string()));
+                            error_message
+                                .set(Some("Failed to store authentication token".to_string()));
                             is_loading.set(false);
                             return;
                         }
@@ -86,7 +87,7 @@ pub fn Login(props: &LoginProps) -> Html {
                             is_loading.set(false);
                             return;
                         }
-                        
+
                         is_loading.set(false);
                         on_login.emit(token);
                     }
@@ -172,21 +173,25 @@ pub fn Login(props: &LoginProps) -> Html {
 }
 
 /// Perform login using the CalDAV auth service
-async fn perform_login(server_url: String, username: String, password: String) -> Result<(String, String), String> {
+async fn perform_login(
+    server_url: String,
+    username: String,
+    password: String,
+) -> Result<(String, String), String> {
     use crate::auth::{AuthService, CalDAVLoginRequest};
     use serde_json;
-    
+
     web_sys::console::log_1(&format!("📡 Creating auth service and request...").into());
-    
+
     let auth_service = AuthService::new();
-    let request = CalDAVLoginRequest { 
-        server_url: server_url.clone(), 
-        username: username.clone(), 
-        password: password.clone() 
+    let request = CalDAVLoginRequest {
+        server_url: server_url.clone(),
+        username: username.clone(),
+        password: password.clone(),
     };
-    
+
     web_sys::console::log_1(&format!("🚀 Sending login request to backend...").into());
-    
+
     match auth_service.login(request).await {
         Ok(response) => {
             web_sys::console::log_1(&format!("✅ Backend responded successfully").into());
@@ -197,10 +202,10 @@ async fn perform_login(server_url: String, username: String, password: String) -
                 "password": password
             });
             Ok((response.token, credentials.to_string()))
-        },
+        }
         Err(err) => {
             web_sys::console::log_1(&format!("❌ Backend error: {}", err).into());
             Err(err)
-        },
+        }
     }
-}
\ No newline at end of file
+}
diff --git a/frontend/src/components/mod.rs b/frontend/src/components/mod.rs
index 3e01c0d..3a3a6fb 100644
--- a/frontend/src/components/mod.rs
+++ b/frontend/src/components/mod.rs
@@ -1,31 +1,33 @@
-pub mod login;
 pub mod calendar;
-pub mod calendar_header;
-pub mod month_view;
-pub mod week_view;
-pub mod event_modal;
-pub mod create_calendar_modal;
-pub mod context_menu;
-pub mod event_context_menu;
 pub mod calendar_context_menu;
-pub mod create_event_modal;
-pub mod sidebar;
+pub mod calendar_header;
 pub mod calendar_list_item;
-pub mod route_handler;
+pub mod context_menu;
+pub mod create_calendar_modal;
+pub mod create_event_modal;
+pub mod event_context_menu;
+pub mod event_modal;
+pub mod login;
+pub mod month_view;
 pub mod recurring_edit_modal;
+pub mod route_handler;
+pub mod sidebar;
+pub mod week_view;
 
-pub use login::Login;
 pub use calendar::Calendar;
-pub use calendar_header::CalendarHeader;
-pub use month_view::MonthView;
-pub use week_view::WeekView;
-pub use event_modal::EventModal;
-pub use create_calendar_modal::CreateCalendarModal;
-pub use context_menu::ContextMenu;
-pub use event_context_menu::{EventContextMenu, DeleteAction, EditAction};
 pub use calendar_context_menu::CalendarContextMenu;
-pub use create_event_modal::{CreateEventModal, EventCreationData, EventStatus, EventClass, ReminderType, RecurrenceType};
-pub use sidebar::{Sidebar, ViewMode, Theme};
+pub use calendar_header::CalendarHeader;
 pub use calendar_list_item::CalendarListItem;
+pub use context_menu::ContextMenu;
+pub use create_calendar_modal::CreateCalendarModal;
+pub use create_event_modal::{
+    CreateEventModal, EventClass, EventCreationData, EventStatus, RecurrenceType, ReminderType,
+};
+pub use event_context_menu::{DeleteAction, EditAction, EventContextMenu};
+pub use event_modal::EventModal;
+pub use login::Login;
+pub use month_view::MonthView;
+pub use recurring_edit_modal::{RecurringEditAction, RecurringEditModal};
 pub use route_handler::RouteHandler;
-pub use recurring_edit_modal::{RecurringEditModal, RecurringEditAction};
\ No newline at end of file
+pub use sidebar::{Sidebar, Theme, ViewMode};
+pub use week_view::WeekView;
diff --git a/frontend/src/components/month_view.rs b/frontend/src/components/month_view.rs
index 814dcbc..9956880 100644
--- a/frontend/src/components/month_view.rs
+++ b/frontend/src/components/month_view.rs
@@ -1,10 +1,10 @@
-use yew::prelude::*;
+use crate::models::ical::VEvent;
+use crate::services::calendar_service::UserInfo;
 use chrono::{Datelike, NaiveDate, Weekday};
 use std::collections::HashMap;
-use web_sys::window;
 use wasm_bindgen::{prelude::*, JsCast};
-use crate::services::calendar_service::UserInfo;
-use crate::models::ical::VEvent;
+use web_sys::window;
+use yew::prelude::*;
 
 #[derive(Properties, PartialEq)]
 pub struct MonthViewProps {
@@ -52,30 +52,33 @@ pub fn month_view(props: &MonthViewProps) -> Html {
         let calculate_max_events = calculate_max_events.clone();
         use_effect_with((), move |_| {
             let calculate_max_events_clone = calculate_max_events.clone();
-            
+
             // Initial calculation with a slight delay to ensure DOM is ready
             if let Some(window) = window() {
                 let timeout_closure = Closure::wrap(Box::new(move || {
                     calculate_max_events_clone();
                 }) as Box<dyn FnMut()>);
-                
+
                 let _ = window.set_timeout_with_callback_and_timeout_and_arguments_0(
                     timeout_closure.as_ref().unchecked_ref(),
                     100,
                 );
                 timeout_closure.forget();
             }
-            
+
             // Setup resize listener
             let resize_closure = Closure::wrap(Box::new(move || {
                 calculate_max_events();
             }) as Box<dyn Fn()>);
-            
+
             if let Some(window) = window() {
-                let _ = window.add_event_listener_with_callback("resize", resize_closure.as_ref().unchecked_ref());
+                let _ = window.add_event_listener_with_callback(
+                    "resize",
+                    resize_closure.as_ref().unchecked_ref(),
+                );
                 resize_closure.forget(); // Keep the closure alive
             }
-            
+
             || {}
         });
     }
@@ -84,8 +87,11 @@ pub fn month_view(props: &MonthViewProps) -> Html {
     let get_event_color = |event: &VEvent| -> String {
         if let Some(user_info) = &props.user_info {
             if let Some(calendar_path) = &event.calendar_path {
-                if let Some(calendar) = user_info.calendars.iter()
-                    .find(|cal| &cal.path == calendar_path) {
+                if let Some(calendar) = user_info
+                    .calendars
+                    .iter()
+                    .find(|cal| &cal.path == calendar_path)
+                {
                     return calendar.color.clone();
                 }
             }
@@ -103,7 +109,7 @@ pub fn month_view(props: &MonthViewProps) -> Html {
             <div class="weekday-header">{"Thu"}</div>
             <div class="weekday-header">{"Fri"}</div>
             <div class="weekday-header">{"Sat"}</div>
-            
+
             // Days from previous month (grayed out)
             {
                 days_from_prev_month.iter().map(|day| {
@@ -112,7 +118,7 @@ pub fn month_view(props: &MonthViewProps) -> Html {
                     }
                 }).collect::<Html>()
             }
-            
+
             // Days of the current month
             {
                 (1..=days_in_month).map(|day| {
@@ -120,16 +126,16 @@ pub fn month_view(props: &MonthViewProps) -> Html {
                     let is_today = date == props.today;
                     let is_selected = props.selected_date == Some(date);
                     let day_events = props.events.get(&date).cloned().unwrap_or_default();
-                    
+
                     // Calculate visible events and overflow
                     let max_events = *max_events_per_day as usize;
                     let visible_events: Vec<_> = day_events.iter().take(max_events).collect();
                     let hidden_count = day_events.len().saturating_sub(max_events);
-                    
+
                     html! {
-                        <div 
+                        <div
                             class={classes!(
-                                "calendar-day", 
+                                "calendar-day",
                                 if is_today { Some("today") } else { None },
                                 if is_selected { Some("selected") } else { None }
                             )}
@@ -162,7 +168,7 @@ pub fn month_view(props: &MonthViewProps) -> Html {
                                     visible_events.iter().map(|event| {
                                         let event_color = get_event_color(event);
                                         let is_refreshing = props.refreshing_event_uid.as_ref() == Some(&event.uid);
-                                        
+
                                         let onclick = {
                                             let on_event_click = props.on_event_click.clone();
                                             let event = (*event).clone();
@@ -170,7 +176,7 @@ pub fn month_view(props: &MonthViewProps) -> Html {
                                                 on_event_click.emit(event.clone());
                                             })
                                         };
-                                        
+
                                         let oncontextmenu = {
                                             if let Some(callback) = &props.on_event_context_menu {
                                                 let callback = callback.clone();
@@ -183,9 +189,9 @@ pub fn month_view(props: &MonthViewProps) -> Html {
                                                 None
                                             }
                                         };
-                                        
+
                                         html! {
-                                            <div 
+                                            <div
                                                 class={classes!("event-box", if is_refreshing { Some("refreshing") } else { None })}
                                                 style={format!("background-color: {}", event_color)}
                                                 {onclick}
@@ -212,7 +218,7 @@ pub fn month_view(props: &MonthViewProps) -> Html {
                     }
                 }).collect::<Html>()
             }
-            
+
             { render_next_month_days(days_from_prev_month.len(), days_in_month) }
         </div>
     }
@@ -221,20 +227,34 @@ pub fn month_view(props: &MonthViewProps) -> Html {
 fn render_next_month_days(prev_days_count: usize, current_days_count: u32) -> Html {
     let total_slots = 42; // 6 rows x 7 days
     let used_slots = prev_days_count + current_days_count as usize;
-    let remaining_slots = if used_slots < total_slots { total_slots - used_slots } else { 0 };
-    
-    (1..=remaining_slots).map(|day| {
-        html! {
-            <div class="calendar-day next-month">{day}</div>
-        }
-    }).collect::<Html>()
+    let remaining_slots = if used_slots < total_slots {
+        total_slots - used_slots
+    } else {
+        0
+    };
+
+    (1..=remaining_slots)
+        .map(|day| {
+            html! {
+                <div class="calendar-day next-month">{day}</div>
+            }
+        })
+        .collect::<Html>()
 }
 
 fn get_days_in_month(date: NaiveDate) -> u32 {
     NaiveDate::from_ymd_opt(
-        if date.month() == 12 { date.year() + 1 } else { date.year() },
-        if date.month() == 12 { 1 } else { date.month() + 1 },
-        1
+        if date.month() == 12 {
+            date.year() + 1
+        } else {
+            date.year()
+        },
+        if date.month() == 12 {
+            1
+        } else {
+            date.month() + 1
+        },
+        1,
     )
     .unwrap()
     .pred_opt()
@@ -252,7 +272,7 @@ fn get_days_from_previous_month(current_month: NaiveDate, first_weekday: Weekday
         Weekday::Fri => 5,
         Weekday::Sat => 6,
     };
-    
+
     if days_before == 0 {
         vec![]
     } else {
@@ -261,8 +281,8 @@ fn get_days_from_previous_month(current_month: NaiveDate, first_weekday: Weekday
         } else {
             NaiveDate::from_ymd_opt(current_month.year(), current_month.month() - 1, 1).unwrap()
         };
-        
+
         let prev_month_days = get_days_in_month(prev_month);
         ((prev_month_days - days_before as u32 + 1)..=prev_month_days).collect()
     }
-}
\ No newline at end of file
+}
diff --git a/frontend/src/components/recurring_edit_modal.rs b/frontend/src/components/recurring_edit_modal.rs
index 51aa764..54e4412 100644
--- a/frontend/src/components/recurring_edit_modal.rs
+++ b/frontend/src/components/recurring_edit_modal.rs
@@ -1,6 +1,6 @@
-use yew::prelude::*;
-use chrono::NaiveDateTime;
 use crate::models::ical::VEvent;
+use chrono::NaiveDateTime;
+use yew::prelude::*;
 
 #[derive(Clone, PartialEq)]
 pub enum RecurringEditAction {
@@ -25,29 +25,34 @@ pub fn recurring_edit_modal(props: &RecurringEditModalProps) -> Html {
         return html! {};
     }
 
-    let event_title = props.event.summary.as_ref().map(|s| s.as_str()).unwrap_or("Untitled Event");
-    
+    let event_title = props
+        .event
+        .summary
+        .as_ref()
+        .map(|s| s.as_str())
+        .unwrap_or("Untitled Event");
+
     let on_this_event = {
         let on_choice = props.on_choice.clone();
         Callback::from(move |_| {
             on_choice.emit(RecurringEditAction::ThisEvent);
         })
     };
-    
+
     let on_future_events = {
         let on_choice = props.on_choice.clone();
         Callback::from(move |_| {
             on_choice.emit(RecurringEditAction::FutureEvents);
         })
     };
-    
+
     let on_all_events = {
         let on_choice = props.on_choice.clone();
         Callback::from(move |_| {
             on_choice.emit(RecurringEditAction::AllEvents);
         })
     };
-    
+
     let on_cancel = {
         let on_cancel = props.on_cancel.clone();
         Callback::from(move |_| {
@@ -64,18 +69,18 @@ pub fn recurring_edit_modal(props: &RecurringEditModalProps) -> Html {
                 <div class="modal-body">
                     <p>{format!("You're modifying \"{}\" which is part of a recurring series.", event_title)}</p>
                     <p>{"How would you like to apply this change?"}</p>
-                    
+
                     <div class="recurring-edit-options">
                         <button class="btn btn-primary recurring-option" onclick={on_this_event}>
                             <div class="option-title">{"This event only"}</div>
                             <div class="option-description">{"Change only this occurrence"}</div>
                         </button>
-                        
+
                         <button class="btn btn-primary recurring-option" onclick={on_future_events}>
                             <div class="option-title">{"This and future events"}</div>
                             <div class="option-description">{"Change this occurrence and all future occurrences"}</div>
                         </button>
-                        
+
                         <button class="btn btn-primary recurring-option" onclick={on_all_events}>
                             <div class="option-title">{"All events in series"}</div>
                             <div class="option-description">{"Change all occurrences in the series"}</div>
@@ -90,4 +95,4 @@ pub fn recurring_edit_modal(props: &RecurringEditModalProps) -> Html {
             </div>
         </div>
     }
-}
\ No newline at end of file
+}
diff --git a/frontend/src/components/route_handler.rs b/frontend/src/components/route_handler.rs
index c64b5ce..1759a3f 100644
--- a/frontend/src/components/route_handler.rs
+++ b/frontend/src/components/route_handler.rs
@@ -1,8 +1,8 @@
+use crate::components::{Login, ViewMode};
+use crate::models::ical::VEvent;
+use crate::services::calendar_service::UserInfo;
 use yew::prelude::*;
 use yew_router::prelude::*;
-use crate::components::{Login, ViewMode};
-use crate::services::calendar_service::UserInfo;
-use crate::models::ical::VEvent;
 
 #[derive(Clone, Routable, PartialEq)]
 pub enum Route {
@@ -28,7 +28,17 @@ pub struct RouteHandlerProps {
     #[prop_or_default]
     pub on_create_event_request: Option<Callback<crate::components::EventCreationData>>,
     #[prop_or_default]
-    pub on_event_update_request: Option<Callback<(VEvent, chrono::NaiveDateTime, chrono::NaiveDateTime, bool, Option<chrono::DateTime<chrono::Utc>>, Option<String>, Option<String>)>>,
+    pub on_event_update_request: Option<
+        Callback<(
+            VEvent,
+            chrono::NaiveDateTime,
+            chrono::NaiveDateTime,
+            bool,
+            Option<chrono::DateTime<chrono::Utc>>,
+            Option<String>,
+            Option<String>,
+        )>,
+    >,
     #[prop_or_default]
     pub context_menus_open: bool,
 }
@@ -44,7 +54,7 @@ pub fn route_handler(props: &RouteHandlerProps) -> Html {
     let on_create_event_request = props.on_create_event_request.clone();
     let on_event_update_request = props.on_event_update_request.clone();
     let context_menus_open = props.context_menus_open;
-    
+
     html! {
         <Switch<Route> render={move |route| {
             let auth_token = auth_token.clone();
@@ -56,7 +66,7 @@ pub fn route_handler(props: &RouteHandlerProps) -> Html {
             let on_create_event_request = on_create_event_request.clone();
             let on_event_update_request = on_event_update_request.clone();
             let context_menus_open = context_menus_open;
-            
+
             match route {
                 Route::Home => {
                     if auth_token.is_some() {
@@ -74,16 +84,16 @@ pub fn route_handler(props: &RouteHandlerProps) -> Html {
                 }
                 Route::Calendar => {
                     if auth_token.is_some() {
-                        html! { 
-                            <CalendarView 
-                                user_info={user_info} 
+                        html! {
+                            <CalendarView
+                                user_info={user_info}
                                 on_event_context_menu={on_event_context_menu}
                                 on_calendar_context_menu={on_calendar_context_menu}
                                 view={view}
                                 on_create_event_request={on_create_event_request}
                                 on_event_update_request={on_event_update_request}
                                 context_menus_open={context_menus_open}
-                            /> 
+                            />
                         }
                     } else {
                         html! { <Redirect<Route> to={Route::Login}/> }
@@ -106,192 +116,36 @@ pub struct CalendarViewProps {
     #[prop_or_default]
     pub on_create_event_request: Option<Callback<crate::components::EventCreationData>>,
     #[prop_or_default]
-    pub on_event_update_request: Option<Callback<(VEvent, chrono::NaiveDateTime, chrono::NaiveDateTime, bool, Option<chrono::DateTime<chrono::Utc>>, Option<String>, Option<String>)>>,
+    pub on_event_update_request: Option<
+        Callback<(
+            VEvent,
+            chrono::NaiveDateTime,
+            chrono::NaiveDateTime,
+            bool,
+            Option<chrono::DateTime<chrono::Utc>>,
+            Option<String>,
+            Option<String>,
+        )>,
+    >,
     #[prop_or_default]
     pub context_menus_open: bool,
 }
 
-use gloo_storage::{LocalStorage, Storage};
-use crate::services::CalendarService;
 use crate::components::Calendar;
-use std::collections::HashMap;
-use chrono::{Local, NaiveDate, Datelike};
 
 #[function_component(CalendarView)]
 pub fn calendar_view(props: &CalendarViewProps) -> Html {
-    let events = use_state(|| HashMap::<NaiveDate, Vec<VEvent>>::new());
-    let loading = use_state(|| true);
-    let error = use_state(|| None::<String>);
-    let refreshing_event = use_state(|| None::<String>);
-    
-    let auth_token: Option<String> = LocalStorage::get("auth_token").ok();
-    
-    
-    let today = Local::now().date_naive();
-    let current_year = today.year();
-    let current_month = today.month();
-    
-    let on_event_click = {
-        let events = events.clone();
-        let refreshing_event = refreshing_event.clone();
-        let auth_token = auth_token.clone();
-        
-        Callback::from(move |event: VEvent| {
-            if let Some(token) = auth_token.clone() {
-                let events = events.clone();
-                let refreshing_event = refreshing_event.clone();
-                let uid = event.uid.clone();
-                
-                refreshing_event.set(Some(uid.clone()));
-                
-                wasm_bindgen_futures::spawn_local(async move {
-                    let calendar_service = CalendarService::new();
-                    
-                    let password = if let Ok(credentials_str) = LocalStorage::get::<String>("caldav_credentials") {
-                        if let Ok(credentials) = serde_json::from_str::<serde_json::Value>(&credentials_str) {
-                            credentials["password"].as_str().unwrap_or("").to_string()
-                        } else {
-                            String::new()
-                        }
-                    } else {
-                        String::new()
-                    };
-                    
-                    match calendar_service.refresh_event(&token, &password, &uid).await {
-                        Ok(Some(refreshed_event)) => {
-                            let refreshed_vevent = refreshed_event; // CalendarEvent is now VEvent
-                            let mut updated_events = (*events).clone();
-                            
-                            for (_, day_events) in updated_events.iter_mut() {
-                                day_events.retain(|e| e.uid != uid);
-                            }
-                            
-                            if refreshed_vevent.rrule.is_some() {
-                                let new_occurrences = CalendarService::expand_recurring_events(vec![refreshed_vevent.clone()]);
-                                
-                                for occurrence in new_occurrences {
-                                    let date = occurrence.get_date();
-                                    updated_events.entry(date)
-                                        .or_insert_with(Vec::new)
-                                        .push(occurrence);
-                                }
-                            } else {
-                                let date = refreshed_vevent.get_date();
-                                updated_events.entry(date)
-                                    .or_insert_with(Vec::new)
-                                    .push(refreshed_vevent);
-                            }
-                            
-                            events.set(updated_events);
-                        }
-                        Ok(None) => {
-                            let mut updated_events = (*events).clone();
-                            for (_, day_events) in updated_events.iter_mut() {
-                                day_events.retain(|e| e.uid != uid);
-                            }
-                            events.set(updated_events);
-                        }
-                        Err(_err) => {
-                        }
-                    }
-                    
-                    refreshing_event.set(None);
-                });
-            }
-        })
-    };
-    
-    {
-        let events = events.clone();
-        let loading = loading.clone();
-        let error = error.clone();
-        let auth_token = auth_token.clone();
-        
-        use_effect_with((), move |_| {
-            if let Some(token) = auth_token {
-                let events = events.clone();
-                let loading = loading.clone();
-                let error = error.clone();
-                
-                wasm_bindgen_futures::spawn_local(async move {
-                    let calendar_service = CalendarService::new();
-                    
-                    let password = if let Ok(credentials_str) = LocalStorage::get::<String>("caldav_credentials") {
-                        if let Ok(credentials) = serde_json::from_str::<serde_json::Value>(&credentials_str) {
-                            credentials["password"].as_str().unwrap_or("").to_string()
-                        } else {
-                            String::new()
-                        }
-                    } else {
-                        String::new()
-                    };
-                    
-                    match calendar_service.fetch_events_for_month_vevent(&token, &password, current_year, current_month).await {
-                        Ok(vevents) => {
-                            let grouped_events = CalendarService::group_events_by_date(vevents);
-                            events.set(grouped_events);
-                            loading.set(false);
-                        }
-                        Err(err) => {
-                            error.set(Some(format!("Failed to load events: {}", err)));
-                            loading.set(false);
-                        }
-                    }
-                });
-            } else {
-                loading.set(false);
-                error.set(Some("No authentication token found".to_string()));
-            }
-            
-            || ()
-        });
-    }
-    
     html! {
         <div class="calendar-view">
-            {
-                if *loading {
-                    html! {
-                        <div class="calendar-loading">
-                            <p>{"Loading calendar events..."}</p>
-                        </div>
-                    }
-                } else if let Some(err) = (*error).clone() {
-                    let dummy_callback = Callback::from(|_: VEvent| {});
-                    html! {
-                        <div class="calendar-error">
-                            <p>{format!("Error: {}", err)}</p>
-                            <Calendar 
-                                events={HashMap::new()} 
-                                on_event_click={dummy_callback} 
-                                refreshing_event_uid={(*refreshing_event).clone()} 
-                                user_info={props.user_info.clone()}
-                                on_event_context_menu={props.on_event_context_menu.clone()}
-                                on_calendar_context_menu={props.on_calendar_context_menu.clone()}
-                                view={props.view.clone()}
-                                on_create_event_request={props.on_create_event_request.clone()}
-                                on_event_update_request={props.on_event_update_request.clone()}
-                                context_menus_open={props.context_menus_open}
-                            />
-                        </div>
-                    }
-                } else {
-                    html! {
-                        <Calendar 
-                            events={(*events).clone()} 
-                            on_event_click={on_event_click} 
-                            refreshing_event_uid={(*refreshing_event).clone()} 
-                            user_info={props.user_info.clone()}
-                            on_event_context_menu={props.on_event_context_menu.clone()}
-                            on_calendar_context_menu={props.on_calendar_context_menu.clone()}
-                            view={props.view.clone()}
-                            on_create_event_request={props.on_create_event_request.clone()}
-                            on_event_update_request={props.on_event_update_request.clone()}
-                            context_menus_open={props.context_menus_open}
-                        />
-                    }
-                }
-            }
+            <Calendar
+                user_info={props.user_info.clone()}
+                on_event_context_menu={props.on_event_context_menu.clone()}
+                on_calendar_context_menu={props.on_calendar_context_menu.clone()}
+                view={props.view.clone()}
+                on_create_event_request={props.on_create_event_request.clone()}
+                on_event_update_request={props.on_event_update_request.clone()}
+                context_menus_open={props.context_menus_open}
+            />
         </div>
     }
-}
\ No newline at end of file
+}
diff --git a/frontend/src/components/sidebar.rs b/frontend/src/components/sidebar.rs
index fc67e96..0afe17d 100644
--- a/frontend/src/components/sidebar.rs
+++ b/frontend/src/components/sidebar.rs
@@ -1,8 +1,8 @@
+use crate::components::CalendarListItem;
+use crate::services::calendar_service::UserInfo;
+use web_sys::HtmlSelectElement;
 use yew::prelude::*;
 use yew_router::prelude::*;
-use web_sys::HtmlSelectElement;
-use crate::services::calendar_service::UserInfo;
-use crate::components::CalendarListItem;
 
 #[derive(Clone, Routable, PartialEq)]
 pub enum Route {
@@ -33,12 +33,11 @@ pub enum Theme {
 }
 
 impl Theme {
-    
     pub fn value(&self) -> &'static str {
         match self {
             Theme::Default => "default",
             Theme::Ocean => "ocean",
-            Theme::Forest => "forest", 
+            Theme::Forest => "forest",
             Theme::Sunset => "sunset",
             Theme::Purple => "purple",
             Theme::Dark => "dark",
@@ -46,7 +45,7 @@ impl Theme {
             Theme::Mint => "mint",
         }
     }
-    
+
     pub fn from_value(value: &str) -> Self {
         match value {
             "ocean" => Theme::Ocean,
@@ -167,14 +166,14 @@ pub fn sidebar(props: &SidebarProps) -> Html {
                 <button onclick={props.on_create_calendar.reform(|_| ())} class="create-calendar-button">
                     {"+ Create Calendar"}
                 </button>
-                
+
                 <div class="view-selector">
                     <select class="view-selector-dropdown" onchange={on_view_change}>
                         <option value="month" selected={matches!(props.current_view, ViewMode::Month)}>{"Month"}</option>
                         <option value="week" selected={matches!(props.current_view, ViewMode::Week)}>{"Week"}</option>
                     </select>
                 </div>
-                
+
                 <div class="theme-selector">
                     <select class="theme-selector-dropdown" onchange={on_theme_change}>
                         <option value="default" selected={matches!(props.current_theme, Theme::Default)}>{"Default"}</option>
@@ -187,9 +186,9 @@ pub fn sidebar(props: &SidebarProps) -> Html {
                         <option value="mint" selected={matches!(props.current_theme, Theme::Mint)}>{"Mint"}</option>
                     </select>
                 </div>
-                
+
                 <button onclick={props.on_logout.reform(|_| ())} class="logout-button">{"Logout"}</button>
             </div>
         </aside>
     }
-}
\ No newline at end of file
+}
diff --git a/frontend/src/components/week_view.rs b/frontend/src/components/week_view.rs
index 7aaeca2..34511cf 100644
--- a/frontend/src/components/week_view.rs
+++ b/frontend/src/components/week_view.rs
@@ -1,10 +1,10 @@
-use yew::prelude::*;
-use chrono::{Datelike, NaiveDate, Duration, Weekday, Local, Timelike, NaiveDateTime, NaiveTime};
+use crate::components::{EventCreationData, RecurringEditAction, RecurringEditModal};
+use crate::models::ical::VEvent;
+use crate::services::calendar_service::UserInfo;
+use chrono::{Datelike, Duration, Local, NaiveDate, NaiveDateTime, NaiveTime, Timelike, Weekday};
 use std::collections::HashMap;
 use web_sys::MouseEvent;
-use crate::services::calendar_service::UserInfo;
-use crate::models::ical::VEvent;
-use crate::components::{RecurringEditModal, RecurringEditAction, EventCreationData};
+use yew::prelude::*;
 
 #[derive(Properties, PartialEq)]
 pub struct WeekViewProps {
@@ -25,7 +25,17 @@ pub struct WeekViewProps {
     #[prop_or_default]
     pub on_create_event_request: Option<Callback<EventCreationData>>,
     #[prop_or_default]
-    pub on_event_update: Option<Callback<(VEvent, NaiveDateTime, NaiveDateTime, bool, Option<chrono::DateTime<chrono::Utc>>, Option<String>, Option<String>)>>,
+    pub on_event_update: Option<
+        Callback<(
+            VEvent,
+            NaiveDateTime,
+            NaiveDateTime,
+            bool,
+            Option<chrono::DateTime<chrono::Utc>>,
+            Option<String>,
+            Option<String>,
+        )>,
+    >,
     #[prop_or_default]
     pub context_menus_open: bool,
     #[prop_or_default]
@@ -47,20 +57,18 @@ struct DragState {
     start_date: NaiveDate,
     start_y: f64,
     current_y: f64,
-    offset_y: f64, // For event moves, this is the offset from the event's top
+    offset_y: f64,   // For event moves, this is the offset from the event's top
     has_moved: bool, // Track if we've moved enough to constitute a real drag
 }
 
 #[function_component(WeekView)]
 pub fn week_view(props: &WeekViewProps) -> Html {
     let start_of_week = get_start_of_week(props.current_date);
-    let week_days: Vec<NaiveDate> = (0..7)
-        .map(|i| start_of_week + Duration::days(i))
-        .collect();
+    let week_days: Vec<NaiveDate> = (0..7).map(|i| start_of_week + Duration::days(i)).collect();
 
     // Drag state for event creation
     let drag_state = use_state(|| None::<DragState>);
-    
+
     // State for recurring event edit modal
     #[derive(Clone, PartialEq)]
     struct PendingRecurringEdit {
@@ -68,15 +76,18 @@ pub fn week_view(props: &WeekViewProps) -> Html {
         new_start: NaiveDateTime,
         new_end: NaiveDateTime,
     }
-    
+
     let pending_recurring_edit = use_state(|| None::<PendingRecurringEdit>);
 
     // Helper function to get calendar color for an event
     let get_event_color = |event: &VEvent| -> String {
         if let Some(user_info) = &props.user_info {
             if let Some(calendar_path) = &event.calendar_path {
-                if let Some(calendar) = user_info.calendars.iter()
-                    .find(|cal| &cal.path == calendar_path) {
+                if let Some(calendar) = user_info
+                    .calendars
+                    .iter()
+                    .find(|cal| &cal.path == calendar_path)
+                {
                     return calendar.color.clone();
                 }
             }
@@ -85,21 +96,22 @@ pub fn week_view(props: &WeekViewProps) -> Html {
     };
 
     // Generate time labels - 24 hours plus the final midnight boundary
-    let mut time_labels: Vec<String> = (0..24).map(|hour| {
-        if hour == 0 {
-            "12 AM".to_string()
-        } else if hour < 12 {
-            format!("{} AM", hour)
-        } else if hour == 12 {
-            "12 PM".to_string()
-        } else {
-            format!("{} PM", hour - 12)
-        }
-    }).collect();
-    
+    let mut time_labels: Vec<String> = (0..24)
+        .map(|hour| {
+            if hour == 0 {
+                "12 AM".to_string()
+            } else if hour < 12 {
+                format!("{} AM", hour)
+            } else if hour == 12 {
+                "12 PM".to_string()
+            } else {
+                format!("{} PM", hour - 12)
+            }
+        })
+        .collect();
+
     // Add the final midnight boundary to show where the day ends
     time_labels.push("12 AM".to_string());
-    
 
     // Handlers for recurring event modification modal
     let on_recurring_choice = {
@@ -135,35 +147,35 @@ pub fn week_view(props: &WeekViewProps) -> Html {
                         if let Some(update_callback) = &on_event_update {
                             // Extract occurrence date for backend processing
                             let occurrence_date = edit.event.dtstart.format("%Y-%m-%d").to_string();
-                            
+
                             // Send single request to backend with "this_only" scope
                             // Backend will atomically:
                             // 1. Add EXDATE to original series (excludes this occurrence)
                             // 2. Create exception event with RECURRENCE-ID and user's modifications
                             update_callback.emit((
-                                edit.event.clone(),     // Original event (series to modify)
-                                edit.new_start,         // Dragged start time for exception
-                                edit.new_end,           // Dragged end time for exception
-                                true,                   // preserve_rrule = true
-                                None,                   // No until_date for this_only
+                                edit.event.clone(),            // Original event (series to modify)
+                                edit.new_start,                // Dragged start time for exception
+                                edit.new_end,                  // Dragged end time for exception
+                                true,                          // preserve_rrule = true
+                                None,                          // No until_date for this_only
                                 Some("this_only".to_string()), // Update scope
-                                Some(occurrence_date)   // Date of occurrence being modified
+                                Some(occurrence_date),         // Date of occurrence being modified
                             ));
                         }
-                    },
+                    }
                     RecurringEditAction::FutureEvents => {
                         // RFC 5545 Compliant Series Splitting: "This and Future Events"
-                        // 
+                        //
                         // When a user chooses to modify "this and future events" for a recurring series,
                         // we implement a series split operation that:
-                        // 
-                        // 1. **Terminates Original Series**: The existing series is updated with an UNTIL 
+                        //
+                        // 1. **Terminates Original Series**: The existing series is updated with an UNTIL
                         //    clause to stop before the occurrence being modified
-                        // 2. **Creates New Series**: A new recurring series is created starting from the 
+                        // 2. **Creates New Series**: A new recurring series is created starting from the
                         //    occurrence date with the user's modifications (new time, title, etc.)
                         //
                         // Example: User drags Aug 22 occurrence of "Daily 9AM meeting" to 2PM:
-                        // - Original: "Daily 9AM meeting" → ends Aug 21 (UNTIL=Aug22T000000Z) 
+                        // - Original: "Daily 9AM meeting" → ends Aug 21 (UNTIL=Aug22T000000Z)
                         // - New: "Daily 2PM meeting" → starts Aug 22, continues indefinitely
                         //
                         // This approach ensures:
@@ -177,7 +189,8 @@ pub fn week_view(props: &WeekViewProps) -> Html {
                         if let Some(update_callback) = &on_event_update {
                             // Find the original series event (not the occurrence)
                             // UIDs like "uuid-timestamp" need to split on the last hyphen, not the first
-                            let base_uid = if let Some(last_hyphen_pos) = edit.event.uid.rfind('-') {
+                            let base_uid = if let Some(last_hyphen_pos) = edit.event.uid.rfind('-')
+                            {
                                 let suffix = &edit.event.uid[last_hyphen_pos + 1..];
                                 // Check if suffix is numeric (timestamp), if so remove it
                                 if suffix.chars().all(|c| c.is_numeric()) {
@@ -188,9 +201,15 @@ pub fn week_view(props: &WeekViewProps) -> Html {
                             } else {
                                 edit.event.uid.clone()
                             };
-                            
-                            web_sys::console::log_1(&format!("🔍 Looking for original series: '{}' from occurrence: '{}'", base_uid, edit.event.uid).into());
-                            
+
+                            web_sys::console::log_1(
+                                &format!(
+                                    "🔍 Looking for original series: '{}' from occurrence: '{}'",
+                                    base_uid, edit.event.uid
+                                )
+                                .into(),
+                            );
+
                             // Find the original series event by searching for the base UID
                             let mut original_series = None;
                             for events_list in events.values() {
@@ -204,12 +223,15 @@ pub fn week_view(props: &WeekViewProps) -> Html {
                                     break;
                                 }
                             }
-                            
+
                             let original_series = match original_series {
                                 Some(series) => {
-                                    web_sys::console::log_1(&format!("✅ Found original series: '{}'", series.uid).into());
+                                    web_sys::console::log_1(
+                                        &format!("✅ Found original series: '{}'", series.uid)
+                                            .into(),
+                                    );
                                     series
-                                },
+                                }
                                 None => {
                                     web_sys::console::log_1(&format!("⚠️  Could not find original series '{}', using occurrence but fixing UID", base_uid).into());
                                     let mut fallback_event = edit.event.clone();
@@ -218,55 +240,69 @@ pub fn week_view(props: &WeekViewProps) -> Html {
                                     fallback_event
                                 }
                             };
-                            
+
                             // Calculate the day before this occurrence for UNTIL clause
-                            let until_date = edit.event.dtstart.date_naive() - chrono::Duration::days(1);
-                            let until_datetime = until_date.and_time(chrono::NaiveTime::from_hms_opt(23, 59, 59).unwrap());
-                            let until_utc = chrono::DateTime::<chrono::Utc>::from_naive_utc_and_offset(until_datetime, chrono::Utc);
-                            
+                            let until_date =
+                                edit.event.dtstart.date_naive() - chrono::Duration::days(1);
+                            let until_datetime = until_date
+                                .and_time(chrono::NaiveTime::from_hms_opt(23, 59, 59).unwrap());
+                            let until_utc =
+                                chrono::DateTime::<chrono::Utc>::from_naive_utc_and_offset(
+                                    until_datetime,
+                                    chrono::Utc,
+                                );
+
                             web_sys::console::log_1(&format!("🔄 Will set UNTIL {} for original series to end before occurrence {}", 
                                 until_utc.format("%Y-%m-%d %H:%M:%S UTC"),
                                 edit.event.dtstart.format("%Y-%m-%d %H:%M:%S UTC")).into());
-                            
+
                             // Critical: Use the dragged times (new_start/new_end) not the original series times
                             // This ensures the new series reflects the user's drag operation
-                            let new_start = edit.new_start; // The dragged start time  
+                            let new_start = edit.new_start; // The dragged start time
                             let new_end = edit.new_end; // The dragged end time
-                            
+
                             // Extract occurrence date from the dragged event for backend processing
                             // Format: YYYY-MM-DD (e.g., "2025-08-22")
                             // This tells the backend which specific occurrence is being modified
                             let occurrence_date = edit.event.dtstart.format("%Y-%m-%d").to_string();
-                            
+
                             // Send single request to backend with "this_and_future" scope
                             // Backend will atomically:
                             // 1. Add UNTIL clause to original series (stops before occurrence_date)
                             // 2. Create new series starting from occurrence_date with dragged times
                             update_callback.emit((
-                                original_series,    // Original event to terminate
-                                new_start,          // Dragged start time for new series
-                                new_end,            // Dragged end time for new series  
-                                true,               // preserve_rrule = true
-                                Some(until_utc),    // UNTIL date for original series
+                                original_series,                     // Original event to terminate
+                                new_start,       // Dragged start time for new series
+                                new_end,         // Dragged end time for new series
+                                true,            // preserve_rrule = true
+                                Some(until_utc), // UNTIL date for original series
                                 Some("this_and_future".to_string()), // Update scope
-                                Some(occurrence_date) // Date of occurrence being modified
+                                Some(occurrence_date), // Date of occurrence being modified
                             ));
                         }
-                    },
+                    }
                     RecurringEditAction::AllEvents => {
                         // Modify the entire series
                         let series_event = edit.event.clone();
-                        
+
                         if let Some(callback) = &on_event_update {
-                            callback.emit((series_event, edit.new_start, edit.new_end, true, None, Some("all_in_series".to_string()), None)); // Regular drag operation - preserve RRULE, update_scope = all_in_series
+                            callback.emit((
+                                series_event,
+                                edit.new_start,
+                                edit.new_end,
+                                true,
+                                None,
+                                Some("all_in_series".to_string()),
+                                None,
+                            )); // Regular drag operation - preserve RRULE, update_scope = all_in_series
                         }
-                    },
+                    }
                 }
             }
             pending_recurring_edit.set(None);
         })
     };
-    
+
     let on_recurring_cancel = {
         let pending_recurring_edit = pending_recurring_edit.clone();
         Callback::from(move |_| {
@@ -283,7 +319,7 @@ pub fn week_view(props: &WeekViewProps) -> Html {
                     week_days.iter().map(|date| {
                         let is_today = *date == props.today;
                         let weekday_name = get_weekday_name(date.weekday());
-                        
+
                         html! {
                             <div class={classes!("week-day-header", if is_today { Some("today") } else { None })}>
                                 <div class="weekday-name">{weekday_name}</div>
@@ -293,7 +329,7 @@ pub fn week_view(props: &WeekViewProps) -> Html {
                     }).collect::<Html>()
                 }
             </div>
-            
+
             // Scrollable content area with time grid
             <div class="week-content">
                 <div class="time-grid">
@@ -310,18 +346,18 @@ pub fn week_view(props: &WeekViewProps) -> Html {
                             }).collect::<Html>()
                         }
                     </div>
-                    
+
                     // Day columns
                     <div class="week-days-grid">
                         {
                             week_days.iter().enumerate().map(|(_column_index, date)| {
                                 let is_today = *date == props.today;
                                 let day_events = props.events.get(date).cloned().unwrap_or_default();
-                                
+
                                 // Drag event handlers
                                 let drag_state_clone = drag_state.clone();
                                 let date_for_drag = *date;
-                                
+
                                 let onmousedown = {
                                     let drag_state = drag_state_clone.clone();
                                     let context_menus_open = props.context_menus_open;
@@ -331,20 +367,20 @@ pub fn week_view(props: &WeekViewProps) -> Html {
                                         if context_menus_open {
                                             return;
                                         }
-                                        
+
                                         // Only handle left-click (button 0)
                                         if e.button() != 0 {
                                             return;
                                         }
-                                        
+
                                         // Calculate Y position relative to day column container
                                         // Use layer_y which gives coordinates relative to positioned ancestor
                                         let relative_y = e.layer_y() as f64;
                                         let relative_y = if relative_y > 0.0 { relative_y } else { e.offset_y() as f64 };
-                                        
+
                                         // Snap to increment
                                         let snapped_y = snap_to_increment(relative_y, time_increment);
-                                        
+
                                         drag_state.set(Some(DragState {
                                             is_dragging: true,
                                             drag_type: DragType::CreateEvent,
@@ -357,7 +393,7 @@ pub fn week_view(props: &WeekViewProps) -> Html {
                                         e.prevent_default();
                                     })
                                 };
-                                
+
                                 let onmousemove = {
                                     let drag_state = drag_state_clone.clone();
                                     let time_increment = props.time_increment;
@@ -367,27 +403,27 @@ pub fn week_view(props: &WeekViewProps) -> Html {
                                                 // Use layer_y for consistent coordinate calculation
                                                 let mouse_y = e.layer_y() as f64;
                                                 let mouse_y = if mouse_y > 0.0 { mouse_y } else { e.offset_y() as f64 };
-                                                
+
                                                 // For move operations, we now follow the mouse directly since we start at click position
                                                 // For resize operations, we still use the mouse position directly
                                                 let adjusted_y = mouse_y;
-                                                
+
                                                 // Snap to increment
                                                 let snapped_y = snap_to_increment(adjusted_y, time_increment);
-                                                
+
                                                 // Check if we've moved enough to constitute a real drag (5 pixels minimum)
                                                 let movement_distance = (snapped_y - current_drag.start_y).abs();
                                                 if movement_distance > 5.0 {
                                                     current_drag.has_moved = true;
                                                 }
-                                                
+
                                                 current_drag.current_y = snapped_y;
                                                 drag_state.set(Some(current_drag));
                                             }
                                         }
                                     })
                                 };
-                                
+
                                 let onmouseup = {
                                     let drag_state = drag_state_clone.clone();
                                     let on_create_event = props.on_create_event.clone();
@@ -402,24 +438,24 @@ pub fn week_view(props: &WeekViewProps) -> Html {
                                                         // Calculate start and end times
                                                         let start_time = pixels_to_time(current_drag.start_y);
                                                         let end_time = pixels_to_time(current_drag.current_y);
-                                                        
+
                                                         // Ensure start is before end
                                                         let (actual_start, actual_end) = if start_time <= end_time {
                                                             (start_time, end_time)
                                                         } else {
                                                             (end_time, start_time)
                                                         };
-                                                        
+
                                                         // Ensure minimum duration (15 minutes)
                                                         let actual_end = if actual_end.signed_duration_since(actual_start).num_minutes() < 15 {
                                                             actual_start + chrono::Duration::minutes(15)
                                                         } else {
                                                             actual_end
                                                         };
-                                                        
+
                                                         let start_datetime = NaiveDateTime::new(current_drag.start_date, actual_start);
                                                         let end_datetime = NaiveDateTime::new(current_drag.start_date, actual_end);
-                                                        
+
                                                         if let Some(callback) = &on_create_event {
                                                             callback.emit((current_drag.start_date, start_datetime, end_datetime));
                                                         }
@@ -430,17 +466,17 @@ pub fn week_view(props: &WeekViewProps) -> Html {
                                                         // Snap the final position to maintain time increment alignment
                                                         let event_top_position = snap_to_increment(unsnapped_position, time_increment);
                                                         let new_start_time = pixels_to_time(event_top_position);
-                                                        
+
                                                         // Calculate duration from original event
                                                         let original_duration = if let Some(end) = event.dtend {
                                                             end.signed_duration_since(event.dtstart)
                                                         } else {
                                                             chrono::Duration::hours(1) // Default 1 hour
                                                         };
-                                                        
+
                                                         let new_start_datetime = NaiveDateTime::new(current_drag.start_date, new_start_time);
                                                         let new_end_datetime = new_start_datetime + original_duration;
-                                                        
+
                                                         // Check if this is a recurring event
                                                         if event.rrule.is_some() {
                                                             // Show modal for recurring event modification
@@ -459,7 +495,7 @@ pub fn week_view(props: &WeekViewProps) -> Html {
                                                     DragType::ResizeEventStart(event) => {
                                                         // Calculate new start time based on drag position
                                                         let new_start_time = pixels_to_time(current_drag.current_y);
-                                                        
+
                                                         // Keep the original end time
                                                         let original_end = if let Some(end) = event.dtend {
                                                             end.with_timezone(&chrono::Local).naive_local()
@@ -467,16 +503,16 @@ pub fn week_view(props: &WeekViewProps) -> Html {
                                                             // If no end time, use start time + 1 hour as default
                                                             event.dtstart.with_timezone(&chrono::Local).naive_local() + chrono::Duration::hours(1)
                                                         };
-                                                        
+
                                                         let new_start_datetime = NaiveDateTime::new(current_drag.start_date, new_start_time);
-                                                        
+
                                                         // Ensure start is before end (minimum 15 minutes)
                                                         let new_end_datetime = if new_start_datetime >= original_end {
                                                             new_start_datetime + chrono::Duration::minutes(15)
                                                         } else {
                                                             original_end
                                                         };
-                                                        
+
                                                         // Check if this is a recurring event
                                                         if event.rrule.is_some() {
                                                             // Show modal for recurring event modification
@@ -495,19 +531,19 @@ pub fn week_view(props: &WeekViewProps) -> Html {
                                                     DragType::ResizeEventEnd(event) => {
                                                         // Calculate new end time based on drag position
                                                         let new_end_time = pixels_to_time(current_drag.current_y);
-                                                        
+
                                                         // Keep the original start time
                                                         let original_start = event.dtstart.with_timezone(&chrono::Local).naive_local();
-                                                        
+
                                                         let new_end_datetime = NaiveDateTime::new(current_drag.start_date, new_end_time);
-                                                        
+
                                                         // Ensure end is after start (minimum 15 minutes)
                                                         let new_start_datetime = if new_end_datetime <= original_start {
                                                             new_end_datetime - chrono::Duration::minutes(15)
                                                         } else {
                                                             original_start
                                                         };
-                                                        
+
                                                         // Check if this is a recurring event
                                                         if event.rrule.is_some() {
                                                             // Show modal for recurring event modification
@@ -524,15 +560,15 @@ pub fn week_view(props: &WeekViewProps) -> Html {
                                                         }
                                                     }
                                                 }
-                                                
+
                                                 drag_state.set(None);
                                             }
                                         }
                                     })
                                 };
-                                
+
                                 html! {
-                                    <div 
+                                    <div
                                         class={classes!("week-day-column", if is_today { Some("today") } else { None })}
                                         {onmousedown}
                                         {onmousemove}
@@ -554,21 +590,21 @@ pub fn week_view(props: &WeekViewProps) -> Html {
                                             <div class="time-slot-half"></div>
                                             <div class="time-slot-half"></div>
                                         </div>
-                                        
+
                                         // Events positioned absolutely based on their actual times
                                         <div class="events-container">
                                             {
                                                 day_events.iter().filter_map(|event| {
                                                     let (start_pixels, duration_pixels, is_all_day) = calculate_event_position(event, *date);
-                                                    
+
                                                     // Skip events that don't belong on this date or have invalid positioning
                                                     if start_pixels == 0.0 && duration_pixels == 0.0 && !is_all_day {
                                                         return None;
                                                     }
-                                                    
+
                                                     let event_color = get_event_color(event);
                                                     let is_refreshing = props.refreshing_event_uid.as_ref() == Some(&event.uid);
-                                                    
+
                                                     let onclick = {
                                                         let on_event_click = props.on_event_click.clone();
                                                         let event = event.clone();
@@ -577,7 +613,7 @@ pub fn week_view(props: &WeekViewProps) -> Html {
                                                             on_event_click.emit(event.clone());
                                                         })
                                                     };
-                                                    
+
                                                     let onmousedown_event = {
                                                         let drag_state = drag_state.clone();
                                                         let event_for_drag = event.clone();
@@ -585,27 +621,27 @@ pub fn week_view(props: &WeekViewProps) -> Html {
                                                         let _time_increment = props.time_increment;
                                                         Callback::from(move |e: MouseEvent| {
                                                             e.stop_propagation(); // Prevent drag-to-create from starting on event clicks
-                                                            
+
                                                             // Only handle left-click (button 0) for moving
                                                             if e.button() != 0 {
                                                                 return;
                                                             }
-                                                            
+
                                                             // Calculate click position relative to event element
                                                             let click_y_relative = e.layer_y() as f64;
                                                             let click_y_relative = if click_y_relative > 0.0 { click_y_relative } else { e.offset_y() as f64 };
-                                                            
+
                                                             // Get event's current position in day column coordinates
                                                             let (event_start_pixels, _, _) = calculate_event_position(&event_for_drag, date_for_drag);
                                                             let event_start_pixels = event_start_pixels as f64;
-                                                            
+
                                                             // Convert click position to day column coordinates
                                                             let click_y = event_start_pixels + click_y_relative;
-                                                            
+
                                                             // Store the offset from the event's top where the user clicked
                                                             // This will be used to maintain the relative click position
                                                             let offset_y = click_y_relative;
-                                                            
+
                                                             // Start drag tracking from where we clicked (in day column coordinates)
                                                             drag_state.set(Some(DragState {
                                                                 is_dragging: true,
@@ -619,7 +655,7 @@ pub fn week_view(props: &WeekViewProps) -> Html {
                                                             e.prevent_default();
                                                         })
                                                     };
-                                                    
+
                                                     let oncontextmenu = {
                                                         if let Some(callback) = &props.on_event_context_menu {
                                                             let callback = callback.clone();
@@ -633,7 +669,7 @@ pub fn week_view(props: &WeekViewProps) -> Html {
                                                                         return;
                                                                     }
                                                                 }
-                                                                
+
                                                                 e.prevent_default();
                                                                 e.stop_propagation(); // Prevent calendar context menu from also triggering
                                                                 callback.emit((e, event.clone()));
@@ -642,7 +678,7 @@ pub fn week_view(props: &WeekViewProps) -> Html {
                                                             None
                                                         }
                                                     };
-                                                    
+
                                                     // Format time display for the event
                                                     let time_display = if event.all_day {
                                                         "All Day".to_string()
@@ -650,20 +686,20 @@ pub fn week_view(props: &WeekViewProps) -> Html {
                                                         let local_start = event.dtstart.with_timezone(&Local);
                                                         if let Some(end) = event.dtend {
                                                             let local_end = end.with_timezone(&Local);
-                                                            
+
                                                             // Check if both times are in same AM/PM period to avoid redundancy
                                                             let start_is_am = local_start.hour() < 12;
                                                             let end_is_am = local_end.hour() < 12;
-                                                            
+
                                                             if start_is_am == end_is_am {
                                                                 // Same AM/PM period - show "9:00 - 10:30 AM"
-                                                                format!("{} - {}", 
+                                                                format!("{} - {}",
                                                                     local_start.format("%I:%M").to_string().trim_start_matches('0'),
                                                                     local_end.format("%I:%M %p")
                                                                 )
                                                             } else {
                                                                 // Different AM/PM periods - show "9:00 AM - 2:30 PM"
-                                                                format!("{} - {}", 
+                                                                format!("{} - {}",
                                                                     local_start.format("%I:%M %p"),
                                                                     local_end.format("%I:%M %p")
                                                                 )
@@ -673,22 +709,22 @@ pub fn week_view(props: &WeekViewProps) -> Html {
                                                             format!("{}", local_start.format("%I:%M %p"))
                                                         }
                                                     };
-                                                    
+
                                                     // Check if this event is currently being dragged or resized
                                                     let is_being_dragged = if let Some(drag) = (*drag_state).clone() {
                                                         match &drag.drag_type {
-                                                            DragType::MoveEvent(dragged_event) => 
+                                                            DragType::MoveEvent(dragged_event) =>
                                                                 dragged_event.uid == event.uid && drag.is_dragging,
-                                                            DragType::ResizeEventStart(dragged_event) => 
+                                                            DragType::ResizeEventStart(dragged_event) =>
                                                                 dragged_event.uid == event.uid && drag.is_dragging,
-                                                            DragType::ResizeEventEnd(dragged_event) => 
+                                                            DragType::ResizeEventEnd(dragged_event) =>
                                                                 dragged_event.uid == event.uid && drag.is_dragging,
                                                             _ => false,
                                                         }
                                                     } else {
                                                         false
                                                     };
-                                                    
+
                                                     if is_being_dragged {
                                                         // Hide the original event while being dragged
                                                         Some(html! {})
@@ -701,11 +737,11 @@ pub fn week_view(props: &WeekViewProps) -> Html {
                                                             let time_increment = props.time_increment;
                                                             Callback::from(move |e: web_sys::MouseEvent| {
                                                                 e.stop_propagation();
-                                                                
+
                                                                 let relative_y = e.layer_y() as f64;
                                                                 let relative_y = if relative_y > 0.0 { relative_y } else { e.offset_y() as f64 };
                                                                 let snapped_y = snap_to_increment(relative_y, time_increment);
-                                                                
+
                                                                 drag_state.set(Some(DragState {
                                                                     is_dragging: true,
                                                                     drag_type: DragType::ResizeEventStart(event_for_resize.clone()),
@@ -718,7 +754,7 @@ pub fn week_view(props: &WeekViewProps) -> Html {
                                                                 e.prevent_default();
                                                             })
                                                         };
-                                                        
+
                                                         let resize_end_handler = {
                                                             let drag_state = drag_state.clone();
                                                             let event_for_resize = event.clone();
@@ -726,11 +762,11 @@ pub fn week_view(props: &WeekViewProps) -> Html {
                                                             let time_increment = props.time_increment;
                                                             Callback::from(move |e: web_sys::MouseEvent| {
                                                                 e.stop_propagation();
-                                                                
+
                                                                 let relative_y = e.layer_y() as f64;
                                                                 let relative_y = if relative_y > 0.0 { relative_y } else { e.offset_y() as f64 };
                                                                 let snapped_y = snap_to_increment(relative_y, time_increment);
-                                                                
+
                                                                 drag_state.set(Some(DragState {
                                                                     is_dragging: true,
                                                                     drag_type: DragType::ResizeEventEnd(event_for_resize.clone()),
@@ -743,18 +779,18 @@ pub fn week_view(props: &WeekViewProps) -> Html {
                                                                 e.prevent_default();
                                                             })
                                                         };
-                                                        
+
                                                         Some(html! {
-                                                            <div 
+                                                            <div
                                                                 class={classes!(
-                                                                    "week-event", 
+                                                                    "week-event",
                                                                     if is_refreshing { Some("refreshing") } else { None },
                                                                     if is_all_day { Some("all-day") } else { None }
                                                                 )}
                                                                 style={format!(
-                                                                    "background-color: {}; top: {}px; height: {}px;", 
-                                                                    event_color, 
-                                                                    start_pixels, 
+                                                                    "background-color: {}; top: {}px; height: {}px;",
+                                                                    event_color,
+                                                                    start_pixels,
                                                                     duration_pixels
                                                                 )}
                                                                 {onclick}
@@ -764,7 +800,7 @@ pub fn week_view(props: &WeekViewProps) -> Html {
                                                                 // Top resize handle
                                                                 {if !is_all_day {
                                                                     html! {
-                                                                        <div 
+                                                                        <div
                                                                             class="resize-handle resize-handle-top"
                                                                             onmousedown={resize_start_handler}
                                                                         />
@@ -772,7 +808,7 @@ pub fn week_view(props: &WeekViewProps) -> Html {
                                                                 } else {
                                                                     html! {}
                                                                 }}
-                                                                
+
                                                                 // Event content
                                                                 <div class="event-content">
                                                                     <div class="event-title">{event.summary.as_ref().unwrap_or(&"Untitled".to_string())}</div>
@@ -782,11 +818,11 @@ pub fn week_view(props: &WeekViewProps) -> Html {
                                                                         html! {}
                                                                     }}
                                                                 </div>
-                                                                
+
                                                                 // Bottom resize handle
                                                                 {if !is_all_day {
                                                                     html! {
-                                                                        <div 
+                                                                        <div
                                                                             class="resize-handle resize-handle-bottom"
                                                                             onmousedown={resize_end_handler}
                                                                         />
@@ -800,7 +836,7 @@ pub fn week_view(props: &WeekViewProps) -> Html {
                                                 }).collect::<Html>()
                                             }
                                         </div>
-                                        
+
                                         // Temporary event box during drag
                                         {
                                             if let Some(drag) = (*drag_state).clone() {
@@ -810,11 +846,11 @@ pub fn week_view(props: &WeekViewProps) -> Html {
                                                             let start_y = drag.start_y.min(drag.current_y);
                                                             let end_y = drag.start_y.max(drag.current_y);
                                                             let height = (drag.current_y - drag.start_y).abs().max(20.0);
-                                                            
+
                                                             // Convert pixels to times for display
                                                             let start_time = pixels_to_time(start_y);
                                                             let end_time = pixels_to_time(end_y);
-                                                            
+
                                                             html! {
                                                                 <div
                                                                     class="temp-event-box"
@@ -837,9 +873,9 @@ pub fn week_view(props: &WeekViewProps) -> Html {
                                                             };
                                                             let duration_pixels = (original_duration.num_minutes() as f64).max(20.0);
                                                             let new_end_time = new_start_time + original_duration;
-                                                            
+
                                                             let event_color = get_event_color(event);
-                                                            
+
                                                             html! {
                                                                 <div
                                                                     class="temp-event-box moving-event"
@@ -858,17 +894,17 @@ pub fn week_view(props: &WeekViewProps) -> Html {
                                                             } else {
                                                                 event.dtstart.with_timezone(&chrono::Local).naive_local() + chrono::Duration::hours(1)
                                                             };
-                                                            
+
                                                             // Calculate positions for the preview
                                                             let (original_start_pixels, _, _) = calculate_event_position(event, drag.start_date);
                                                             let original_duration = original_end.signed_duration_since(event.dtstart.with_timezone(&chrono::Local).naive_local());
                                                             let original_end_pixels = original_start_pixels + (original_duration.num_minutes() as f32);
-                                                            
+
                                                             let new_start_pixels = drag.current_y;
                                                             let new_height = (original_end_pixels as f64 - new_start_pixels).max(20.0);
-                                                            
+
                                                             let event_color = get_event_color(event);
-                                                            
+
                                                             html! {
                                                                 <div
                                                                     class="temp-event-box resizing-event"
@@ -883,15 +919,15 @@ pub fn week_view(props: &WeekViewProps) -> Html {
                                                             // Show the event being resized from the end
                                                             let new_end_time = pixels_to_time(drag.current_y);
                                                             let original_start = event.dtstart.with_timezone(&chrono::Local).naive_local();
-                                                            
+
                                                             // Calculate positions for the preview
                                                             let (original_start_pixels, _, _) = calculate_event_position(event, drag.start_date);
-                                                            
+
                                                             let new_end_pixels = drag.current_y;
                                                             let new_height = (new_end_pixels - original_start_pixels as f64).max(20.0);
-                                                            
+
                                                             let event_color = get_event_color(event);
-                                                            
+
                                                             html! {
                                                                 <div
                                                                     class="temp-event-box resizing-event"
@@ -917,10 +953,10 @@ pub fn week_view(props: &WeekViewProps) -> Html {
                     </div>
                 </div>
             </div>
-            
+
             // Recurring event modification modal
             if let Some(edit) = (*pending_recurring_edit).clone() {
-                <RecurringEditModal 
+                <RecurringEditModal
                     show={true}
                     event={edit.event}
                     new_start={edit.new_start}
@@ -975,46 +1011,44 @@ fn pixels_to_time(pixels: f64) -> NaiveTime {
     let total_minutes = pixels; // 1px = 1 minute
     let hours = (total_minutes / 60.0) as u32;
     let minutes = (total_minutes % 60.0) as u32;
-    
+
     // Handle midnight boundary - if we're at exactly 1440 pixels (24:00), return midnight
     if total_minutes >= 1440.0 {
         return NaiveTime::from_hms_opt(0, 0, 0).unwrap();
     }
-    
+
     // Clamp to valid time range for within-day times
     let hours = hours.min(23);
     let minutes = minutes.min(59);
-    
+
     NaiveTime::from_hms_opt(hours, minutes, 0).unwrap_or(NaiveTime::from_hms_opt(0, 0, 0).unwrap())
 }
 
-
 fn calculate_event_position(event: &VEvent, date: NaiveDate) -> (f32, f32, bool) {
     // Convert UTC times to local time for display
     let local_start = event.dtstart.with_timezone(&Local);
     let event_date = local_start.date_naive();
-    
+
     // Only position events that are on this specific date
     if event_date != date {
         return (0.0, 0.0, false); // Event not on this date
     }
-    
+
     // Handle all-day events - they appear at the top
     if event.all_day {
         return (0.0, 30.0, true); // Position at top, 30px height, is_all_day = true
     }
-    
+
     // Calculate start position in pixels from midnight
     let start_hour = local_start.hour() as f32;
     let start_minute = local_start.minute() as f32;
     let start_pixels = (start_hour + start_minute / 60.0) * 60.0; // 60px per hour
-    
-    
+
     // Calculate duration and height
     let duration_pixels = if let Some(end) = event.dtend {
         let local_end = end.with_timezone(&Local);
         let end_date = local_end.date_naive();
-        
+
         // Handle events that span multiple days by capping at midnight
         if end_date > date {
             // Event continues past midnight, cap at 24:00 (1440px)
@@ -1028,6 +1062,6 @@ fn calculate_event_position(event: &VEvent, date: NaiveDate) -> (f32, f32, bool)
     } else {
         60.0 // Default 1 hour if no end time
     };
-    
+
     (start_pixels, duration_pixels, false) // is_all_day = false
-}
\ No newline at end of file
+}
diff --git a/frontend/src/main.rs b/frontend/src/main.rs
index da1d4f1..886d751 100644
--- a/frontend/src/main.rs
+++ b/frontend/src/main.rs
@@ -1,4 +1,3 @@
-
 mod app;
 mod auth;
 mod components;
@@ -9,4 +8,4 @@ use app::App;
 
 fn main() {
     yew::Renderer::<App>::new().render();
-}
\ No newline at end of file
+}
diff --git a/frontend/src/models/ical.rs b/frontend/src/models/ical.rs
index bd81c69..5aa4075 100644
--- a/frontend/src/models/ical.rs
+++ b/frontend/src/models/ical.rs
@@ -1,2 +1,2 @@
 // Re-export from shared calendar-models library for backward compatibility
-pub use calendar_models::*;
\ No newline at end of file
+pub use calendar_models::*;
diff --git a/frontend/src/models/mod.rs b/frontend/src/models/mod.rs
index 983dd6b..e679af4 100644
--- a/frontend/src/models/mod.rs
+++ b/frontend/src/models/mod.rs
@@ -1,5 +1,5 @@
 // RFC 5545 Compliant iCalendar Models
 pub mod ical;
 
-// Re-export commonly used types  
-// pub use ical::VEvent;
\ No newline at end of file
+// Re-export commonly used types
+// pub use ical::VEvent;
diff --git a/frontend/src/services/calendar_service.rs b/frontend/src/services/calendar_service.rs
index ca242d8..7a7d7ea 100644
--- a/frontend/src/services/calendar_service.rs
+++ b/frontend/src/services/calendar_service.rs
@@ -1,9 +1,9 @@
-use chrono::{DateTime, Utc, NaiveDate, Datelike, Weekday, Duration, TimeZone};
+use chrono::{DateTime, Datelike, Duration, NaiveDate, TimeZone, Utc, Weekday};
 use serde::{Deserialize, Serialize};
+use std::collections::HashMap;
 use wasm_bindgen::JsCast;
 use wasm_bindgen_futures::JsFuture;
 use web_sys::{Request, RequestInit, RequestMode, Response};
-use std::collections::HashMap;
 
 // Import RFC 5545 compliant VEvent from shared library
 use calendar_models::VEvent;
@@ -92,17 +92,12 @@ pub enum AlarmActionV2 {
 #[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
 pub enum DeleteActionV2 {
     DeleteThis,
-    DeleteFollowing, 
+    DeleteFollowing,
     DeleteSeries,
 }
 
 // V2 Request/Response Models
 
-
-
-
-
-
 #[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
 pub struct EventSummaryV2 {
     pub uid: String,
@@ -115,7 +110,6 @@ pub struct EventSummaryV2 {
     pub etag: Option<String>,
 }
 
-
 pub struct CalendarService {
     base_url: String,
 }
@@ -125,14 +119,14 @@ impl CalendarService {
         let base_url = option_env!("BACKEND_API_URL")
             .unwrap_or("http://localhost:3000/api")
             .to_string();
-        
+
         Self { base_url }
     }
 
     /// Fetch user info including available calendars
     pub async fn fetch_user_info(&self, token: &str, password: &str) -> Result<UserInfo, String> {
         let window = web_sys::window().ok_or("No global window exists")?;
-        
+
         let opts = RequestInit::new();
         opts.set_method("GET");
         opts.set_mode(RequestMode::Cors);
@@ -141,93 +135,117 @@ impl CalendarService {
         let request = Request::new_with_str_and_init(&url, &opts)
             .map_err(|e| format!("Request creation failed: {:?}", e))?;
 
-        request.headers().set("Authorization", &format!("Bearer {}", token))
+        request
+            .headers()
+            .set("Authorization", &format!("Bearer {}", token))
             .map_err(|e| format!("Authorization header setting failed: {:?}", e))?;
-        
-        request.headers().set("X-CalDAV-Password", password)
+
+        request
+            .headers()
+            .set("X-CalDAV-Password", password)
             .map_err(|e| format!("Password header setting failed: {:?}", e))?;
 
         let resp_value = JsFuture::from(window.fetch_with_request(&request))
             .await
             .map_err(|e| format!("Network request failed: {:?}", e))?;
 
-        let resp: Response = resp_value.dyn_into()
+        let resp: Response = resp_value
+            .dyn_into()
             .map_err(|e| format!("Response cast failed: {:?}", e))?;
 
-        let text = JsFuture::from(resp.text()
-            .map_err(|e| format!("Text extraction failed: {:?}", e))?)
-            .await
-            .map_err(|e| format!("Text promise failed: {:?}", e))?;
+        let text = JsFuture::from(
+            resp.text()
+                .map_err(|e| format!("Text extraction failed: {:?}", e))?,
+        )
+        .await
+        .map_err(|e| format!("Text promise failed: {:?}", e))?;
 
-        let text_string = text.as_string()
-            .ok_or("Response text is not a string")?;
+        let text_string = text.as_string().ok_or("Response text is not a string")?;
 
         if resp.ok() {
             let user_info: UserInfo = serde_json::from_str(&text_string)
                 .map_err(|e| format!("JSON parsing failed: {}", e))?;
             Ok(user_info)
         } else {
-            Err(format!("Request failed with status {}: {}", resp.status(), text_string))
+            Err(format!(
+                "Request failed with status {}: {}",
+                resp.status(),
+                text_string
+            ))
         }
     }
 
     /// Fetch calendar events for a specific month
     /// Fetch events for month as VEvent with RFC 5545 compliance  
     pub async fn fetch_events_for_month_vevent(
-        &self, 
-        token: &str, 
+        &self,
+        token: &str,
         password: &str,
-        year: i32, 
-        month: u32
+        year: i32,
+        month: u32,
     ) -> Result<Vec<VEvent>, String> {
         // Since CalendarEvent is now a type alias for VEvent, just call the main method
-        self.fetch_events_for_month(token, password, year, month).await
+        self.fetch_events_for_month(token, password, year, month)
+            .await
     }
 
     pub async fn fetch_events_for_month(
-        &self, 
-        token: &str, 
+        &self,
+        token: &str,
         password: &str,
-        year: i32, 
-        month: u32
+        year: i32,
+        month: u32,
     ) -> Result<Vec<CalendarEvent>, String> {
         let window = web_sys::window().ok_or("No global window exists")?;
-        
+
         let opts = RequestInit::new();
         opts.set_method("GET");
         opts.set_mode(RequestMode::Cors);
 
-        let url = format!("{}/calendar/events?year={}&month={}", self.base_url, year, month);
+        let url = format!(
+            "{}/calendar/events?year={}&month={}",
+            self.base_url, year, month
+        );
         let request = Request::new_with_str_and_init(&url, &opts)
             .map_err(|e| format!("Request creation failed: {:?}", e))?;
 
-        request.headers().set("Authorization", &format!("Bearer {}", token))
+        request
+            .headers()
+            .set("Authorization", &format!("Bearer {}", token))
             .map_err(|e| format!("Authorization header setting failed: {:?}", e))?;
-        
-        request.headers().set("X-CalDAV-Password", password)
+
+        request
+            .headers()
+            .set("X-CalDAV-Password", password)
             .map_err(|e| format!("Password header setting failed: {:?}", e))?;
 
         let resp_value = JsFuture::from(window.fetch_with_request(&request))
             .await
             .map_err(|e| format!("Network request failed: {:?}", e))?;
 
-        let resp: Response = resp_value.dyn_into()
+        let resp: Response = resp_value
+            .dyn_into()
             .map_err(|e| format!("Response cast failed: {:?}", e))?;
 
-        let text = JsFuture::from(resp.text()
-            .map_err(|e| format!("Text extraction failed: {:?}", e))?)
-            .await
-            .map_err(|e| format!("Text promise failed: {:?}", e))?;
+        let text = JsFuture::from(
+            resp.text()
+                .map_err(|e| format!("Text extraction failed: {:?}", e))?,
+        )
+        .await
+        .map_err(|e| format!("Text promise failed: {:?}", e))?;
 
-        let text_string = text.as_string()
-            .ok_or("Response text is not a string")?;
+        let text_string = text.as_string().ok_or("Response text is not a string")?;
 
         if resp.ok() {
             let events: Vec<CalendarEvent> = serde_json::from_str(&text_string)
                 .map_err(|e| format!("JSON parsing failed: {}", e))?;
             Ok(events)
         } else {
-            Err(format!("Request failed with status {}: {}", resp.status(), text_string))
+            Err(format!(
+                "Request failed with status {}: {}",
+                resp.status(),
+                text_string
+            ))
         }
     }
 
@@ -236,60 +254,70 @@ impl CalendarService {
     /// Group VEvents by date with RFC 5545 compliance
     pub fn group_events_by_date(events: Vec<VEvent>) -> HashMap<NaiveDate, Vec<VEvent>> {
         let mut grouped = HashMap::new();
-        
+
         // Expand recurring events using VEvent (better RFC 5545 compliance)
         let expanded_vevents = Self::expand_recurring_events(events);
-        
+
         // Group by date
         for vevent in expanded_vevents {
             let date = vevent.get_date();
             grouped.entry(date).or_insert_with(Vec::new).push(vevent);
         }
-        
+
         grouped
     }
 
-
     /// Expand recurring events using VEvent (RFC 5545 compliant)
     pub fn expand_recurring_events(events: Vec<VEvent>) -> Vec<VEvent> {
         let mut expanded_events = Vec::new();
         let today = chrono::Utc::now().date_naive();
         let start_range = today - Duration::days(30); // Show past 30 days
-        let end_range = today + Duration::days(365);   // Show next 365 days
-        
+        let end_range = today + Duration::days(365); // Show next 365 days
+
         for event in events {
             if let Some(ref rrule) = event.rrule {
-                web_sys::console::log_1(&format!("📅 Processing recurring VEvent '{}' with RRULE: {}", 
-                    event.summary.as_deref().unwrap_or("Untitled"), 
-                    rrule
-                ).into());
-                
+                web_sys::console::log_1(
+                    &format!(
+                        "📅 Processing recurring VEvent '{}' with RRULE: {}",
+                        event.summary.as_deref().unwrap_or("Untitled"),
+                        rrule
+                    )
+                    .into(),
+                );
+
                 // Log if event has exception dates
                 if !event.exdate.is_empty() {
-                    web_sys::console::log_1(&format!("📅 VEvent '{}' has {} exception dates: {:?}", 
-                        event.summary.as_deref().unwrap_or("Untitled"), 
-                        event.exdate.len(),
-                        event.exdate
-                    ).into());
+                    web_sys::console::log_1(
+                        &format!(
+                            "📅 VEvent '{}' has {} exception dates: {:?}",
+                            event.summary.as_deref().unwrap_or("Untitled"),
+                            event.exdate.len(),
+                            event.exdate
+                        )
+                        .into(),
+                    );
                 }
-                
+
                 // Generate occurrences for recurring events using VEvent
                 let occurrences = Self::generate_occurrences(&event, rrule, start_range, end_range);
-                web_sys::console::log_1(&format!("📅 Generated {} occurrences for VEvent '{}'", 
-                    occurrences.len(),
-                    event.summary.as_deref().unwrap_or("Untitled")
-                ).into());
+                web_sys::console::log_1(
+                    &format!(
+                        "📅 Generated {} occurrences for VEvent '{}'",
+                        occurrences.len(),
+                        event.summary.as_deref().unwrap_or("Untitled")
+                    )
+                    .into(),
+                );
                 expanded_events.extend(occurrences);
             } else {
                 // Non-recurring event - add as-is
                 expanded_events.push(event);
             }
         }
-        
+
         expanded_events
     }
 
-
     /// Generate occurrence dates for a recurring VEvent based on RRULE (RFC 5545 compliant)
     fn generate_occurrences(
         base_event: &VEvent,
@@ -298,11 +326,11 @@ impl CalendarService {
         end_range: NaiveDate,
     ) -> Vec<VEvent> {
         let mut occurrences = Vec::new();
-        
+
         // Parse RRULE components
         let rrule_upper = rrule.to_uppercase();
         web_sys::console::log_1(&format!("🔄 Parsing RRULE: {}", rrule_upper).into());
-        
+
         let components: HashMap<String, String> = rrule_upper
             .split(';')
             .filter_map(|part| {
@@ -316,35 +344,44 @@ impl CalendarService {
             .collect();
 
         // Get frequency
-        let freq = components.get("FREQ").map(|s| s.as_str()).unwrap_or("DAILY");
-        
+        let freq = components
+            .get("FREQ")
+            .map(|s| s.as_str())
+            .unwrap_or("DAILY");
+
         // Get interval (default 1)
-        let interval: i32 = components.get("INTERVAL")
+        let interval: i32 = components
+            .get("INTERVAL")
             .and_then(|s| s.parse().ok())
             .unwrap_or(1);
 
         // Get count limit (default 100 to prevent infinite loops)
-        let count: usize = components.get("COUNT")
+        let count: usize = components
+            .get("COUNT")
             .and_then(|s| s.parse().ok())
             .unwrap_or(100)
             .min(365); // Cap at 365 occurrences for performance
 
         // Get UNTIL date if specified
-        let until_date = components.get("UNTIL")
-            .and_then(|until_str| {
-                // Parse UNTIL date in YYYYMMDDTHHMMSSZ format
-                if let Ok(dt) = chrono::NaiveDateTime::parse_from_str(until_str.trim_end_matches('Z'), "%Y%m%dT%H%M%S") {
-                    Some(chrono::Utc.from_utc_datetime(&dt))
-                } else if let Ok(dt) = chrono::DateTime::parse_from_str(until_str, "%Y%m%dT%H%M%SZ") {
-                    Some(dt.with_timezone(&chrono::Utc))
-                } else if let Ok(date) = chrono::NaiveDate::parse_from_str(until_str, "%Y%m%d") {
-                    // Handle date-only UNTIL
-                    Some(chrono::Utc.from_utc_datetime(&date.and_hms_opt(23, 59, 59).unwrap()))
-                } else {
-                    web_sys::console::log_1(&format!("⚠️ Failed to parse UNTIL date: {}", until_str).into());
-                    None
-                }
-            });
+        let until_date = components.get("UNTIL").and_then(|until_str| {
+            // Parse UNTIL date in YYYYMMDDTHHMMSSZ format
+            if let Ok(dt) = chrono::NaiveDateTime::parse_from_str(
+                until_str.trim_end_matches('Z'),
+                "%Y%m%dT%H%M%S",
+            ) {
+                Some(chrono::Utc.from_utc_datetime(&dt))
+            } else if let Ok(dt) = chrono::DateTime::parse_from_str(until_str, "%Y%m%dT%H%M%SZ") {
+                Some(dt.with_timezone(&chrono::Utc))
+            } else if let Ok(date) = chrono::NaiveDate::parse_from_str(until_str, "%Y%m%d") {
+                // Handle date-only UNTIL
+                Some(chrono::Utc.from_utc_datetime(&date.and_hms_opt(23, 59, 59).unwrap()))
+            } else {
+                web_sys::console::log_1(
+                    &format!("⚠️ Failed to parse UNTIL date: {}", until_str).into(),
+                );
+                None
+            }
+        });
 
         if let Some(until) = until_date {
             web_sys::console::log_1(&format!("📅 RRULE has UNTIL: {}", until).into());
@@ -358,50 +395,60 @@ impl CalendarService {
         while current_date <= end_range && occurrence_count < count {
             // Check UNTIL constraint - stop if current occurrence is after UNTIL date
             if let Some(until) = until_date {
-                let current_datetime = base_event.dtstart + Duration::days(current_date.signed_duration_since(start_date).num_days());
+                let current_datetime = base_event.dtstart
+                    + Duration::days(current_date.signed_duration_since(start_date).num_days());
                 if current_datetime > until {
-                    web_sys::console::log_1(&format!("🛑 Stopping at {} due to UNTIL {}", current_datetime, until).into());
+                    web_sys::console::log_1(
+                        &format!("🛑 Stopping at {} due to UNTIL {}", current_datetime, until)
+                            .into(),
+                    );
                     break;
                 }
             }
-            
+
             if current_date >= start_range {
                 // Calculate the occurrence datetime
                 let days_diff = current_date.signed_duration_since(start_date).num_days();
                 let occurrence_datetime = base_event.dtstart + Duration::days(days_diff);
-                
+
                 // Check if this occurrence is in the exception dates (EXDATE)
                 let is_exception = base_event.exdate.iter().any(|exception_date| {
                     // Compare dates ignoring sub-second precision
                     let exception_naive = exception_date.naive_utc();
                     let occurrence_naive = occurrence_datetime.naive_utc();
-                    
+
                     // Check if dates match (within a minute to handle minor time differences)
                     let diff = occurrence_naive - exception_naive;
                     let matches = diff.num_seconds().abs() < 60;
-                    
+
                     if matches {
-                        web_sys::console::log_1(&format!("🚫 Excluding occurrence {} due to EXDATE {}", occurrence_naive, exception_naive).into());
+                        web_sys::console::log_1(
+                            &format!(
+                                "🚫 Excluding occurrence {} due to EXDATE {}",
+                                occurrence_naive, exception_naive
+                            )
+                            .into(),
+                        );
                     }
-                    
+
                     matches
                 });
-                
+
                 if !is_exception {
                     // Create occurrence event with updated DTSTAMP
                     let mut occurrence_event = base_event.clone();
                     occurrence_event.dtstart = occurrence_datetime;
                     occurrence_event.dtstamp = chrono::Utc::now(); // Update DTSTAMP for each occurrence
-                    
+
                     if let Some(end) = base_event.dtend {
                         occurrence_event.dtend = Some(end + Duration::days(days_diff));
                     }
-                    
+
                     occurrences.push(occurrence_event);
                     occurrence_count += 1; // Only count when we actually add an occurrence
                 }
             }
-            
+
             // Calculate next occurrence date
             match freq {
                 "DAILY" => {
@@ -412,13 +459,13 @@ impl CalendarService {
                         // For BYDAY weekly events, we need to handle multiple days per week
                         // Break out of the single-occurrence loop and use specialized logic
                         return Self::generate_weekly_byday_occurrences(
-                            base_event, 
-                            byday, 
-                            interval, 
-                            start_range, 
-                            end_range, 
-                            until_date, 
-                            count
+                            base_event,
+                            byday,
+                            interval,
+                            start_range,
+                            end_range,
+                            until_date,
+                            count,
                         );
                     } else {
                         current_date = current_date + Duration::weeks(interval as i64);
@@ -435,7 +482,7 @@ impl CalendarService {
                             start_range,
                             end_range,
                             until_date,
-                            count
+                            count,
                         );
                     } else if let Some(byday) = components.get("BYDAY") {
                         // Monthly by weekday position (e.g., first Monday)
@@ -446,7 +493,7 @@ impl CalendarService {
                             start_range,
                             end_range,
                             until_date,
-                            count
+                            count,
                         );
                     } else {
                         // Simple monthly increment (same day of month)
@@ -467,7 +514,7 @@ impl CalendarService {
                             start_range,
                             end_range,
                             until_date,
-                            count
+                            count,
                         );
                     } else {
                         // Simple yearly increment (same date each year)
@@ -481,7 +528,7 @@ impl CalendarService {
                 _ => break, // Unsupported frequency
             }
         }
-        
+
         occurrences
     }
 
@@ -497,37 +544,37 @@ impl CalendarService {
     ) -> Vec<VEvent> {
         let mut occurrences = Vec::new();
         let weekdays = Self::parse_byday(byday);
-        
+
         if weekdays.is_empty() {
             return occurrences;
         }
 
-
         let start_date = base_event.dtstart.date_naive();
-        
+
         // Find the Monday of the week containing the start_date (reference week)
-        let reference_week_start = start_date - Duration::days(start_date.weekday().num_days_from_monday() as i64);
-        
+        let reference_week_start =
+            start_date - Duration::days(start_date.weekday().num_days_from_monday() as i64);
+
         let mut total_events_generated = 0; // Count of actual events generated (matches RFC 5545 COUNT)
         let mut week_interval_number = 0; // Which interval week we're processing (0, 1, 2, ...)
         let max_weeks = (count * 10).min(520); // Prevent infinite loops - max 10 years
-        
 
         // Continue generating until we reach count or date limits
         while total_events_generated < count && week_interval_number < max_weeks {
             // Calculate the actual week we're processing: original + (interval_number * interval) weeks
-            let current_week_start = reference_week_start + Duration::weeks((week_interval_number as i32 * interval) as i64);
-            
+            let current_week_start = reference_week_start
+                + Duration::weeks((week_interval_number as i32 * interval) as i64);
+
             // Stop if we've gone past the end range
             if current_week_start > end_range {
                 break;
             }
-            
-            
+
             // Generate occurrences for all matching weekdays in this week
             for &weekday in &weekdays {
-                let occurrence_date = current_week_start + Duration::days(weekday.num_days_from_monday() as i64);
-                
+                let occurrence_date =
+                    current_week_start + Duration::days(weekday.num_days_from_monday() as i64);
+
                 // Skip if occurrence is before start_range or after end_range
                 if occurrence_date < start_range || occurrence_date > end_range {
                     continue;
@@ -543,7 +590,13 @@ impl CalendarService {
                     let days_diff = occurrence_date.signed_duration_since(start_date).num_days();
                     let occurrence_datetime = base_event.dtstart + Duration::days(days_diff);
                     if occurrence_datetime > until {
-                        web_sys::console::log_1(&format!("🛑 Stopping at {} due to UNTIL {}", occurrence_datetime, until).into());
+                        web_sys::console::log_1(
+                            &format!(
+                                "🛑 Stopping at {} due to UNTIL {}",
+                                occurrence_datetime, until
+                            )
+                            .into(),
+                        );
                         return occurrences;
                     }
                 }
@@ -558,11 +611,17 @@ impl CalendarService {
                     let occurrence_naive = occurrence_datetime.naive_utc();
                     let diff = occurrence_naive - exception_naive;
                     let matches = diff.num_seconds().abs() < 60;
-                    
+
                     if matches {
-                        web_sys::console::log_1(&format!("🚫 Excluding occurrence {} due to EXDATE {}", occurrence_naive, exception_naive).into());
+                        web_sys::console::log_1(
+                            &format!(
+                                "🚫 Excluding occurrence {} due to EXDATE {}",
+                                occurrence_naive, exception_naive
+                            )
+                            .into(),
+                        );
                     }
-                    
+
                     matches
                 });
 
@@ -571,14 +630,14 @@ impl CalendarService {
                     let mut occurrence_event = base_event.clone();
                     occurrence_event.dtstart = occurrence_datetime;
                     occurrence_event.dtstamp = chrono::Utc::now();
-                    
+
                     if let Some(end) = base_event.dtend {
                         occurrence_event.dtend = Some(end + Duration::days(days_diff));
                     }
-                    
+
                     total_events_generated += 1;
                     occurrences.push(occurrence_event);
-                    
+
                     // Stop if we've reached the count limit
                     if total_events_generated >= count {
                         return occurrences;
@@ -604,7 +663,7 @@ impl CalendarService {
         count: usize,
     ) -> Vec<VEvent> {
         let mut occurrences = Vec::new();
-        
+
         // Parse BYMONTHDAY (e.g., "15" or "1,15,31")
         let monthdays: Vec<u32> = bymonthday
             .split(',')
@@ -616,25 +675,31 @@ impl CalendarService {
             return occurrences;
         }
 
-
         let start_date = base_event.dtstart.date_naive();
-        let mut current_month_start = NaiveDate::from_ymd_opt(start_date.year(), start_date.month(), 1).unwrap();
+        let mut current_month_start =
+            NaiveDate::from_ymd_opt(start_date.year(), start_date.month(), 1).unwrap();
         let mut total_occurrences = 0;
         let mut months_processed = 0;
         let max_months = (count * 12).min(120); // Prevent infinite loops - max 10 years
 
-
         // Generate occurrences month by month
-        while current_month_start <= end_range && total_occurrences < count && months_processed < max_months {
+        while current_month_start <= end_range
+            && total_occurrences < count
+            && months_processed < max_months
+        {
             // Generate occurrences for all matching days in this month
             for &day in &monthdays {
                 // Try to create the date, skip if invalid (e.g., Feb 31)
-                if let Some(occurrence_date) = NaiveDate::from_ymd_opt(current_month_start.year(), current_month_start.month(), day) {
+                if let Some(occurrence_date) = NaiveDate::from_ymd_opt(
+                    current_month_start.year(),
+                    current_month_start.month(),
+                    day,
+                ) {
                     // Skip if occurrence is before start_range or after end_range
                     if occurrence_date < start_range || occurrence_date > end_range {
                         continue;
                     }
-                    
+
                     // Skip if we've reached the count limit
                     if total_occurrences >= count {
                         break;
@@ -647,10 +712,17 @@ impl CalendarService {
 
                     // Check UNTIL constraint
                     if let Some(until) = until_date {
-                        let days_diff = occurrence_date.signed_duration_since(start_date).num_days();
+                        let days_diff =
+                            occurrence_date.signed_duration_since(start_date).num_days();
                         let occurrence_datetime = base_event.dtstart + Duration::days(days_diff);
                         if occurrence_datetime > until {
-                            web_sys::console::log_1(&format!("🛑 Stopping at {} due to UNTIL {}", occurrence_datetime, until).into());
+                            web_sys::console::log_1(
+                                &format!(
+                                    "🛑 Stopping at {} due to UNTIL {}",
+                                    occurrence_datetime, until
+                                )
+                                .into(),
+                            );
                             return occurrences;
                         }
                     }
@@ -672,11 +744,11 @@ impl CalendarService {
                         let mut occurrence_event = base_event.clone();
                         occurrence_event.dtstart = occurrence_datetime;
                         occurrence_event.dtstamp = chrono::Utc::now();
-                        
+
                         if let Some(end) = base_event.dtend {
                             occurrence_event.dtend = Some(end + Duration::days(days_diff));
                         }
-                        
+
                         occurrences.push(occurrence_event);
                         total_occurrences += 1;
                     }
@@ -686,7 +758,9 @@ impl CalendarService {
             // Move to next month interval
             months_processed += 1;
             if let Some(next_month_start) = Self::add_months(current_month_start, interval) {
-                current_month_start = NaiveDate::from_ymd_opt(next_month_start.year(), next_month_start.month(), 1).unwrap();
+                current_month_start =
+                    NaiveDate::from_ymd_opt(next_month_start.year(), next_month_start.month(), 1)
+                        .unwrap();
             } else {
                 break;
             }
@@ -707,30 +781,35 @@ impl CalendarService {
     ) -> Vec<VEvent> {
         let mut occurrences = Vec::new();
 
-
         // Parse BYDAY for monthly (e.g., "1MO" = first Monday, "-1FR" = last Friday)
         if let Some((position, weekday)) = Self::parse_monthly_byday(byday) {
             let start_date = base_event.dtstart.date_naive();
-            let mut current_month_start = NaiveDate::from_ymd_opt(start_date.year(), start_date.month(), 1).unwrap();
+            let mut current_month_start =
+                NaiveDate::from_ymd_opt(start_date.year(), start_date.month(), 1).unwrap();
             let mut total_occurrences = 0;
 
             // Generate occurrences month by month
             while current_month_start <= end_range && total_occurrences < count {
-                if let Some(occurrence_date) = Self::find_nth_weekday_in_month(current_month_start, position, weekday) {
+                if let Some(occurrence_date) =
+                    Self::find_nth_weekday_in_month(current_month_start, position, weekday)
+                {
                     // Skip if occurrence is before start_range or after end_range
                     if occurrence_date < start_range || occurrence_date > end_range {
                     } else if occurrence_date >= start_date && total_occurrences < count {
                         // Check UNTIL constraint
                         if let Some(until) = until_date {
-                            let days_diff = occurrence_date.signed_duration_since(start_date).num_days();
-                            let occurrence_datetime = base_event.dtstart + Duration::days(days_diff);
+                            let days_diff =
+                                occurrence_date.signed_duration_since(start_date).num_days();
+                            let occurrence_datetime =
+                                base_event.dtstart + Duration::days(days_diff);
                             if occurrence_datetime > until {
                                 return occurrences;
                             }
                         }
 
                         // Calculate the occurrence datetime
-                        let days_diff = occurrence_date.signed_duration_since(start_date).num_days();
+                        let days_diff =
+                            occurrence_date.signed_duration_since(start_date).num_days();
                         let occurrence_datetime = base_event.dtstart + Duration::days(days_diff);
 
                         // Check EXDATE
@@ -745,11 +824,11 @@ impl CalendarService {
                             let mut occurrence_event = base_event.clone();
                             occurrence_event.dtstart = occurrence_datetime;
                             occurrence_event.dtstamp = chrono::Utc::now();
-                            
+
                             if let Some(end) = base_event.dtend {
                                 occurrence_event.dtend = Some(end + Duration::days(days_diff));
                             }
-                            
+
                             occurrences.push(occurrence_event);
                             total_occurrences += 1;
                         }
@@ -758,7 +837,8 @@ impl CalendarService {
 
                 // Move to next month interval
                 if let Some(next_month) = Self::add_months(current_month_start, interval) {
-                    current_month_start = NaiveDate::from_ymd_opt(next_month.year(), next_month.month(), 1).unwrap();
+                    current_month_start =
+                        NaiveDate::from_ymd_opt(next_month.year(), next_month.month(), 1).unwrap();
                 } else {
                     break;
                 }
@@ -779,7 +859,7 @@ impl CalendarService {
         count: usize,
     ) -> Vec<VEvent> {
         let mut occurrences = Vec::new();
-        
+
         // Parse BYMONTH (e.g., "1,3,6" -> [January, March, June])
         let months: Vec<u32> = bymonth
             .split(',')
@@ -791,7 +871,6 @@ impl CalendarService {
             return occurrences;
         }
 
-
         let start_date = base_event.dtstart.date_naive();
         let mut current_year = start_date.year();
         let mut total_occurrences = 0;
@@ -801,12 +880,14 @@ impl CalendarService {
             // Generate occurrences for all matching months in this year
             for &month in &months {
                 // Create the date for this year/month/day
-                if let Some(occurrence_date) = NaiveDate::from_ymd_opt(current_year, month, start_date.day()) {
+                if let Some(occurrence_date) =
+                    NaiveDate::from_ymd_opt(current_year, month, start_date.day())
+                {
                     // Skip if occurrence is before start_range or after end_range
                     if occurrence_date < start_range || occurrence_date > end_range {
                         continue;
                     }
-                    
+
                     // Skip if we've reached the count limit
                     if total_occurrences >= count {
                         break;
@@ -819,7 +900,8 @@ impl CalendarService {
 
                     // Check UNTIL constraint
                     if let Some(until) = until_date {
-                        let days_diff = occurrence_date.signed_duration_since(start_date).num_days();
+                        let days_diff =
+                            occurrence_date.signed_duration_since(start_date).num_days();
                         let occurrence_datetime = base_event.dtstart + Duration::days(days_diff);
                         if occurrence_datetime > until {
                             return occurrences;
@@ -842,11 +924,11 @@ impl CalendarService {
                         let mut occurrence_event = base_event.clone();
                         occurrence_event.dtstart = occurrence_datetime;
                         occurrence_event.dtstamp = chrono::Utc::now();
-                        
+
                         if let Some(end) = base_event.dtend {
                             occurrence_event.dtend = Some(end + Duration::days(days_diff));
                         }
-                        
+
                         occurrences.push(occurrence_event);
                         total_occurrences += 1;
                     }
@@ -855,7 +937,7 @@ impl CalendarService {
 
             // Move to next year interval
             current_year += interval;
-            
+
             // Stop if we've gone beyond reasonable range
             if current_year > end_range.year() + 10 {
                 break;
@@ -865,8 +947,6 @@ impl CalendarService {
         occurrences
     }
 
-
-
     /// Parse BYDAY parameter (e.g., "MO,WE,FR" -> [Monday, Wednesday, Friday])
     fn parse_byday(byday: &str) -> Vec<Weekday> {
         byday
@@ -884,12 +964,11 @@ impl CalendarService {
             .collect()
     }
 
-
     /// Add months to a date (handling month boundary issues)
     fn add_months(date: NaiveDate, months: i32) -> Option<NaiveDate> {
         let mut year = date.year();
         let mut month = date.month() as i32 + months;
-        
+
         while month > 12 {
             year += 1;
             month -= 12;
@@ -898,10 +977,10 @@ impl CalendarService {
             year -= 1;
             month += 12;
         }
-        
+
         // Handle day overflow (e.g., Jan 31 -> Feb 28)
         let day = date.day().min(Self::days_in_month(year, month as u32));
-        
+
         NaiveDate::from_ymd_opt(year, month as u32, day)
     }
 
@@ -915,7 +994,13 @@ impl CalendarService {
         match month {
             1 | 3 | 5 | 7 | 8 | 10 | 12 => 31,
             4 | 6 | 9 | 11 => 30,
-            2 => if Self::is_leap_year(year) { 29 } else { 28 },
+            2 => {
+                if Self::is_leap_year(year) {
+                    29
+                } else {
+                    28
+                }
+            }
             _ => 30,
         }
     }
@@ -927,15 +1012,15 @@ impl CalendarService {
 
     /// Create a new calendar on the CalDAV server
     pub async fn create_calendar(
-        &self, 
-        token: &str, 
+        &self,
+        token: &str,
         password: &str,
         name: String,
         description: Option<String>,
-        color: Option<String>
+        color: Option<String>,
     ) -> Result<(), String> {
         let window = web_sys::window().ok_or("No global window exists")?;
-        
+
         let opts = RequestInit::new();
         opts.set_method("POST");
         opts.set_mode(RequestMode::Cors);
@@ -955,88 +1040,108 @@ impl CalendarService {
         let request = Request::new_with_str_and_init(&url, &opts)
             .map_err(|e| format!("Request creation failed: {:?}", e))?;
 
-        request.headers().set("Authorization", &format!("Bearer {}", token))
+        request
+            .headers()
+            .set("Authorization", &format!("Bearer {}", token))
             .map_err(|e| format!("Authorization header setting failed: {:?}", e))?;
-        
-        request.headers().set("X-CalDAV-Password", password)
+
+        request
+            .headers()
+            .set("X-CalDAV-Password", password)
             .map_err(|e| format!("Password header setting failed: {:?}", e))?;
 
-        request.headers().set("Content-Type", "application/json")
+        request
+            .headers()
+            .set("Content-Type", "application/json")
             .map_err(|e| format!("Content-Type header setting failed: {:?}", e))?;
 
         let resp_value = JsFuture::from(window.fetch_with_request(&request))
             .await
             .map_err(|e| format!("Network request failed: {:?}", e))?;
 
-        let resp: Response = resp_value.dyn_into()
+        let resp: Response = resp_value
+            .dyn_into()
             .map_err(|e| format!("Response cast failed: {:?}", e))?;
 
-        let text = JsFuture::from(resp.text()
-            .map_err(|e| format!("Text extraction failed: {:?}", e))?)
-            .await
-            .map_err(|e| format!("Text promise failed: {:?}", e))?;
+        let text = JsFuture::from(
+            resp.text()
+                .map_err(|e| format!("Text extraction failed: {:?}", e))?,
+        )
+        .await
+        .map_err(|e| format!("Text promise failed: {:?}", e))?;
 
-        let text_string = text.as_string()
-            .ok_or("Response text is not a string")?;
+        let text_string = text.as_string().ok_or("Response text is not a string")?;
 
         if resp.ok() {
             Ok(())
         } else {
-            Err(format!("Request failed with status {}: {}", resp.status(), text_string))
+            Err(format!(
+                "Request failed with status {}: {}",
+                resp.status(),
+                text_string
+            ))
         }
     }
 
     /// Delete an event from the CalDAV server
     pub async fn delete_event(
-        &self, 
-        token: &str, 
+        &self,
+        token: &str,
         password: &str,
         calendar_path: String,
         event_href: String,
         delete_action: String,
-        occurrence_date: Option<String>
+        occurrence_date: Option<String>,
     ) -> Result<String, String> {
         // Forward to delete_event_with_uid with extracted UID
         let event_uid = event_href.trim_end_matches(".ics").to_string();
         self.delete_event_with_uid(
-            token, password, calendar_path, event_href, delete_action, 
-            occurrence_date, event_uid, None // No recurrence info available
-        ).await
+            token,
+            password,
+            calendar_path,
+            event_href,
+            delete_action,
+            occurrence_date,
+            event_uid,
+            None, // No recurrence info available
+        )
+        .await
     }
 
     /// Delete an event from the CalDAV server with UID and recurrence support
     pub async fn delete_event_with_uid(
-        &self, 
-        token: &str, 
+        &self,
+        token: &str,
         password: &str,
         calendar_path: String,
         event_href: String,
         delete_action: String,
         occurrence_date: Option<String>,
         event_uid: String,
-        recurrence: Option<String>
+        recurrence: Option<String>,
     ) -> Result<String, String> {
         let window = web_sys::window().ok_or("No global window exists")?;
-        
+
         let opts = RequestInit::new();
         opts.set_method("POST");
         opts.set_mode(RequestMode::Cors);
 
         // Determine if this is a series event based on recurrence
-        let is_series = recurrence.as_ref()
+        let is_series = recurrence
+            .as_ref()
             .map(|r| !r.is_empty() && r.to_uppercase() != "NONE")
             .unwrap_or(false);
-        
+
         let (body, url) = if is_series {
             // Use series-specific endpoint and payload for recurring events
             // Map delete_action to delete_scope for series endpoint
             let delete_scope = match delete_action.as_str() {
                 "delete_this" => "this_only",
-                "delete_following" => "this_and_future", 
+                "delete_following" => "this_and_future",
                 "delete_series" => "all_in_series",
-                _ => "this_only" // Default to single occurrence
+                _ => "this_only", // Default to single occurrence
             };
-            
+
             let body = serde_json::json!({
                 "series_uid": event_uid,
                 "calendar_path": calendar_path,
@@ -1064,38 +1169,53 @@ impl CalendarService {
         let request = Request::new_with_str_and_init(&url, &opts)
             .map_err(|e| format!("Request creation failed: {:?}", e))?;
 
-        request.headers().set("Authorization", &format!("Bearer {}", token))
+        request
+            .headers()
+            .set("Authorization", &format!("Bearer {}", token))
             .map_err(|e| format!("Authorization header setting failed: {:?}", e))?;
-        
-        request.headers().set("X-CalDAV-Password", password)
+
+        request
+            .headers()
+            .set("X-CalDAV-Password", password)
             .map_err(|e| format!("Password header setting failed: {:?}", e))?;
 
-        request.headers().set("Content-Type", "application/json")
+        request
+            .headers()
+            .set("Content-Type", "application/json")
             .map_err(|e| format!("Content-Type header setting failed: {:?}", e))?;
 
         let resp_value = JsFuture::from(window.fetch_with_request(&request))
             .await
             .map_err(|e| format!("Network request failed: {:?}", e))?;
 
-        let resp: Response = resp_value.dyn_into()
+        let resp: Response = resp_value
+            .dyn_into()
             .map_err(|e| format!("Response cast failed: {:?}", e))?;
 
-        let text = JsFuture::from(resp.text()
-            .map_err(|e| format!("Text extraction failed: {:?}", e))?)
-            .await
-            .map_err(|e| format!("Text promise failed: {:?}", e))?;
+        let text = JsFuture::from(
+            resp.text()
+                .map_err(|e| format!("Text extraction failed: {:?}", e))?,
+        )
+        .await
+        .map_err(|e| format!("Text promise failed: {:?}", e))?;
 
-        let text_string = text.as_string()
-            .ok_or("Response text is not a string")?;
+        let text_string = text.as_string().ok_or("Response text is not a string")?;
 
         if resp.ok() {
             // Parse the response to get the message
             let response: serde_json::Value = serde_json::from_str(&text_string)
                 .map_err(|e| format!("Failed to parse response JSON: {}", e))?;
-            let message = response["message"].as_str().unwrap_or("Event deleted successfully").to_string();
+            let message = response["message"]
+                .as_str()
+                .unwrap_or("Event deleted successfully")
+                .to_string();
             Ok(message)
         } else {
-            Err(format!("Request failed with status {}: {}", resp.status(), text_string))
+            Err(format!(
+                "Request failed with status {}: {}",
+                resp.status(),
+                text_string
+            ))
         }
     }
 
@@ -1103,7 +1223,7 @@ impl CalendarService {
     pub async fn create_event(
         &self,
         token: &str,
-        password: &str, 
+        password: &str,
         title: String,
         description: String,
         start_date: String,
@@ -1121,17 +1241,17 @@ impl CalendarService {
         reminder: String,
         recurrence: String,
         recurrence_days: Vec<bool>,
-        calendar_path: Option<String>
+        calendar_path: Option<String>,
     ) -> Result<(), String> {
         let window = web_sys::window().ok_or("No global window exists")?;
-        
+
         let opts = RequestInit::new();
         opts.set_method("POST");
         opts.set_mode(RequestMode::Cors);
 
         // Determine if this is a series event based on recurrence
         let is_series = !recurrence.is_empty() && recurrence.to_uppercase() != "NONE";
-        
+
         let (body, url) = if is_series {
             // Use series-specific endpoint and payload for recurring events
             let body = serde_json::json!({
@@ -1191,34 +1311,46 @@ impl CalendarService {
         let request = Request::new_with_str_and_init(&url, &opts)
             .map_err(|e| format!("Request creation failed: {:?}", e))?;
 
-        request.headers().set("Authorization", &format!("Bearer {}", token))
+        request
+            .headers()
+            .set("Authorization", &format!("Bearer {}", token))
             .map_err(|e| format!("Authorization header setting failed: {:?}", e))?;
-        
-        request.headers().set("X-CalDAV-Password", password)
+
+        request
+            .headers()
+            .set("X-CalDAV-Password", password)
             .map_err(|e| format!("Password header setting failed: {:?}", e))?;
 
-        request.headers().set("Content-Type", "application/json")
+        request
+            .headers()
+            .set("Content-Type", "application/json")
             .map_err(|e| format!("Content-Type header setting failed: {:?}", e))?;
 
         let resp_value = JsFuture::from(window.fetch_with_request(&request))
             .await
             .map_err(|e| format!("Network request failed: {:?}", e))?;
 
-        let resp: Response = resp_value.dyn_into()
+        let resp: Response = resp_value
+            .dyn_into()
             .map_err(|e| format!("Response cast failed: {:?}", e))?;
 
-        let text = JsFuture::from(resp.text()
-            .map_err(|e| format!("Text extraction failed: {:?}", e))?)
-            .await
-            .map_err(|e| format!("Text promise failed: {:?}", e))?;
+        let text = JsFuture::from(
+            resp.text()
+                .map_err(|e| format!("Text extraction failed: {:?}", e))?,
+        )
+        .await
+        .map_err(|e| format!("Text promise failed: {:?}", e))?;
 
-        let text_string = text.as_string()
-            .ok_or("Response text is not a string")?;
+        let text_string = text.as_string().ok_or("Response text is not a string")?;
 
         if resp.ok() {
             Ok(())
         } else {
-            Err(format!("Request failed with status {}: {}", resp.status(), text_string))
+            Err(format!(
+                "Request failed with status {}: {}",
+                resp.status(),
+                text_string
+            ))
         }
     }
 
@@ -1247,16 +1379,36 @@ impl CalendarService {
         calendar_path: Option<String>,
         exception_dates: Vec<DateTime<Utc>>,
         update_action: Option<String>,
-        until_date: Option<DateTime<Utc>>
+        until_date: Option<DateTime<Utc>>,
     ) -> Result<(), String> {
         // Forward to update_event_with_scope with default scope
         self.update_event_with_scope(
-            token, password, event_uid, title, description,
-            start_date, start_time, end_date, end_time, location,
-            all_day, status, class, priority, organizer, attendees,
-            categories, reminder, recurrence, recurrence_days,
-            calendar_path, exception_dates, update_action, until_date
-        ).await
+            token,
+            password,
+            event_uid,
+            title,
+            description,
+            start_date,
+            start_time,
+            end_date,
+            end_time,
+            location,
+            all_day,
+            status,
+            class,
+            priority,
+            organizer,
+            attendees,
+            categories,
+            reminder,
+            recurrence,
+            recurrence_days,
+            calendar_path,
+            exception_dates,
+            update_action,
+            until_date,
+        )
+        .await
     }
 
     pub async fn update_event_with_scope(
@@ -1284,10 +1436,10 @@ impl CalendarService {
         calendar_path: Option<String>,
         exception_dates: Vec<DateTime<Utc>>,
         update_action: Option<String>,
-        until_date: Option<DateTime<Utc>>
+        until_date: Option<DateTime<Utc>>,
     ) -> Result<(), String> {
         let window = web_sys::window().ok_or("No global window exists")?;
-        
+
         let opts = RequestInit::new();
         opts.set_method("POST");
         opts.set_mode(RequestMode::Cors);
@@ -1326,46 +1478,58 @@ impl CalendarService {
         let request = Request::new_with_str_and_init(&url, &opts)
             .map_err(|e| format!("Request creation failed: {:?}", e))?;
 
-        request.headers().set("Authorization", &format!("Bearer {}", token))
+        request
+            .headers()
+            .set("Authorization", &format!("Bearer {}", token))
             .map_err(|e| format!("Authorization header setting failed: {:?}", e))?;
-        
-        request.headers().set("X-CalDAV-Password", password)
+
+        request
+            .headers()
+            .set("X-CalDAV-Password", password)
             .map_err(|e| format!("Password header setting failed: {:?}", e))?;
 
-        request.headers().set("Content-Type", "application/json")
+        request
+            .headers()
+            .set("Content-Type", "application/json")
             .map_err(|e| format!("Content-Type header setting failed: {:?}", e))?;
 
         let resp_value = JsFuture::from(window.fetch_with_request(&request))
             .await
             .map_err(|e| format!("Network request failed: {:?}", e))?;
 
-        let resp: Response = resp_value.dyn_into()
+        let resp: Response = resp_value
+            .dyn_into()
             .map_err(|e| format!("Response cast failed: {:?}", e))?;
 
-        let text = JsFuture::from(resp.text()
-            .map_err(|e| format!("Text extraction failed: {:?}", e))?)
-            .await
-            .map_err(|e| format!("Text promise failed: {:?}", e))?;
+        let text = JsFuture::from(
+            resp.text()
+                .map_err(|e| format!("Text extraction failed: {:?}", e))?,
+        )
+        .await
+        .map_err(|e| format!("Text promise failed: {:?}", e))?;
 
-        let text_string = text.as_string()
-            .ok_or("Response text is not a string")?;
+        let text_string = text.as_string().ok_or("Response text is not a string")?;
 
         if resp.ok() {
             Ok(())
         } else {
-            Err(format!("Request failed with status {}: {}", resp.status(), text_string))
+            Err(format!(
+                "Request failed with status {}: {}",
+                resp.status(),
+                text_string
+            ))
         }
     }
 
     /// Delete a calendar from the CalDAV server
     pub async fn delete_calendar(
-        &self, 
-        token: &str, 
+        &self,
+        token: &str,
         password: &str,
-        path: String
+        path: String,
     ) -> Result<(), String> {
         let window = web_sys::window().ok_or("No global window exists")?;
-        
+
         let opts = RequestInit::new();
         opts.set_method("POST");
         opts.set_mode(RequestMode::Cors);
@@ -1383,41 +1547,58 @@ impl CalendarService {
         let request = Request::new_with_str_and_init(&url, &opts)
             .map_err(|e| format!("Request creation failed: {:?}", e))?;
 
-        request.headers().set("Authorization", &format!("Bearer {}", token))
+        request
+            .headers()
+            .set("Authorization", &format!("Bearer {}", token))
             .map_err(|e| format!("Authorization header setting failed: {:?}", e))?;
-        
-        request.headers().set("X-CalDAV-Password", password)
+
+        request
+            .headers()
+            .set("X-CalDAV-Password", password)
             .map_err(|e| format!("Password header setting failed: {:?}", e))?;
 
-        request.headers().set("Content-Type", "application/json")
+        request
+            .headers()
+            .set("Content-Type", "application/json")
             .map_err(|e| format!("Content-Type header setting failed: {:?}", e))?;
 
         let resp_value = JsFuture::from(window.fetch_with_request(&request))
             .await
             .map_err(|e| format!("Network request failed: {:?}", e))?;
 
-        let resp: Response = resp_value.dyn_into()
+        let resp: Response = resp_value
+            .dyn_into()
             .map_err(|e| format!("Response cast failed: {:?}", e))?;
 
-        let text = JsFuture::from(resp.text()
-            .map_err(|e| format!("Text extraction failed: {:?}", e))?)
-            .await
-            .map_err(|e| format!("Text promise failed: {:?}", e))?;
+        let text = JsFuture::from(
+            resp.text()
+                .map_err(|e| format!("Text extraction failed: {:?}", e))?,
+        )
+        .await
+        .map_err(|e| format!("Text promise failed: {:?}", e))?;
 
-        let text_string = text.as_string()
-            .ok_or("Response text is not a string")?;
+        let text_string = text.as_string().ok_or("Response text is not a string")?;
 
         if resp.ok() {
             Ok(())
         } else {
-            Err(format!("Request failed with status {}: {}", resp.status(), text_string))
+            Err(format!(
+                "Request failed with status {}: {}",
+                resp.status(),
+                text_string
+            ))
         }
     }
 
     /// Refresh a single event by UID from the CalDAV server
-    pub async fn refresh_event(&self, token: &str, password: &str, uid: &str) -> Result<Option<CalendarEvent>, String> {
+    pub async fn refresh_event(
+        &self,
+        token: &str,
+        password: &str,
+        uid: &str,
+    ) -> Result<Option<CalendarEvent>, String> {
         let window = web_sys::window().ok_or("No global window exists")?;
-        
+
         let opts = RequestInit::new();
         opts.set_method("GET");
         opts.set_mode(RequestMode::Cors);
@@ -1426,33 +1607,43 @@ impl CalendarService {
         let request = Request::new_with_str_and_init(&url, &opts)
             .map_err(|e| format!("Request creation failed: {:?}", e))?;
 
-        request.headers().set("Authorization", &format!("Bearer {}", token))
+        request
+            .headers()
+            .set("Authorization", &format!("Bearer {}", token))
             .map_err(|e| format!("Authorization header setting failed: {:?}", e))?;
-        
-        request.headers().set("X-CalDAV-Password", password)
+
+        request
+            .headers()
+            .set("X-CalDAV-Password", password)
             .map_err(|e| format!("Password header setting failed: {:?}", e))?;
 
         let resp_value = JsFuture::from(window.fetch_with_request(&request))
             .await
             .map_err(|e| format!("Network request failed: {:?}", e))?;
 
-        let resp: Response = resp_value.dyn_into()
+        let resp: Response = resp_value
+            .dyn_into()
             .map_err(|e| format!("Response cast failed: {:?}", e))?;
 
-        let text = JsFuture::from(resp.text()
-            .map_err(|e| format!("Text extraction failed: {:?}", e))?)
-            .await
-            .map_err(|e| format!("Text promise failed: {:?}", e))?;
+        let text = JsFuture::from(
+            resp.text()
+                .map_err(|e| format!("Text extraction failed: {:?}", e))?,
+        )
+        .await
+        .map_err(|e| format!("Text promise failed: {:?}", e))?;
 
-        let text_string = text.as_string()
-            .ok_or("Response text is not a string")?;
+        let text_string = text.as_string().ok_or("Response text is not a string")?;
 
         if resp.ok() {
             let event: Option<CalendarEvent> = serde_json::from_str(&text_string)
                 .map_err(|e| format!("JSON parsing failed: {}", e))?;
             Ok(event)
         } else {
-            Err(format!("Request failed with status {}: {}", resp.status(), text_string))
+            Err(format!(
+                "Request failed with status {}: {}",
+                resp.status(),
+                text_string
+            ))
         }
     }
 
@@ -1482,7 +1673,7 @@ impl CalendarService {
         occurrence_date: Option<String>,
     ) -> Result<(), String> {
         let window = web_sys::window().ok_or("No global window exists")?;
-        
+
         let opts = RequestInit::new();
         opts.set_method("POST");
         opts.set_mode(RequestMode::Cors);
@@ -1513,11 +1704,19 @@ impl CalendarService {
             "update_scope": update_scope,
             "occurrence_date": occurrence_date
         });
-        
+
         let url = format!("{}/calendar/events/series/update", self.base_url);
-        
-        web_sys::console::log_1(&format!("🔄 update_series: Making request to URL: {}", url).into());
-        web_sys::console::log_1(&format!("🔄 update_series: Request body: {}", serde_json::to_string_pretty(&body).unwrap_or_default()).into());
+
+        web_sys::console::log_1(
+            &format!("🔄 update_series: Making request to URL: {}", url).into(),
+        );
+        web_sys::console::log_1(
+            &format!(
+                "🔄 update_series: Request body: {}",
+                serde_json::to_string_pretty(&body).unwrap_or_default()
+            )
+            .into(),
+        );
 
         let body_string = serde_json::to_string(&body)
             .map_err(|e| format!("JSON serialization failed: {}", e))?;
@@ -1525,34 +1724,46 @@ impl CalendarService {
         let request = Request::new_with_str_and_init(&url, &opts)
             .map_err(|e| format!("Request creation failed: {:?}", e))?;
 
-        request.headers().set("Authorization", &format!("Bearer {}", token))
+        request
+            .headers()
+            .set("Authorization", &format!("Bearer {}", token))
             .map_err(|e| format!("Authorization header setting failed: {:?}", e))?;
-        
-        request.headers().set("X-CalDAV-Password", password)
+
+        request
+            .headers()
+            .set("X-CalDAV-Password", password)
             .map_err(|e| format!("Password header setting failed: {:?}", e))?;
 
-        request.headers().set("Content-Type", "application/json")
+        request
+            .headers()
+            .set("Content-Type", "application/json")
             .map_err(|e| format!("Content-Type header setting failed: {:?}", e))?;
 
         let resp_value = JsFuture::from(window.fetch_with_request(&request))
             .await
             .map_err(|e| format!("Network request failed: {:?}", e))?;
 
-        let resp: Response = resp_value.dyn_into()
+        let resp: Response = resp_value
+            .dyn_into()
             .map_err(|e| format!("Response cast failed: {:?}", e))?;
 
-        let text = JsFuture::from(resp.text()
-            .map_err(|e| format!("Text extraction failed: {:?}", e))?)
-            .await
-            .map_err(|e| format!("Text promise failed: {:?}", e))?;
+        let text = JsFuture::from(
+            resp.text()
+                .map_err(|e| format!("Text extraction failed: {:?}", e))?,
+        )
+        .await
+        .map_err(|e| format!("Text promise failed: {:?}", e))?;
 
-        let text_string = text.as_string()
-            .ok_or("Response text is not a string")?;
+        let text_string = text.as_string().ok_or("Response text is not a string")?;
 
         if resp.ok() {
             Ok(())
         } else {
-            Err(format!("Request failed with status {}: {}", resp.status(), text_string))
+            Err(format!(
+                "Request failed with status {}: {}",
+                resp.status(),
+                text_string
+            ))
         }
     }
 
@@ -1561,14 +1772,14 @@ impl CalendarService {
         if byday.len() < 3 {
             return None;
         }
-        
+
         // Extract position and weekday
         let (position_str, weekday_str) = if byday.starts_with('-') {
             (&byday[..2], &byday[2..])
         } else {
             (&byday[..1], &byday[1..])
         };
-        
+
         let position = position_str.parse::<i8>().ok()?;
         let weekday = match weekday_str {
             "MO" => chrono::Weekday::Mon,
@@ -1580,20 +1791,24 @@ impl CalendarService {
             "SU" => chrono::Weekday::Sun,
             _ => return None,
         };
-        
+
         Some((position, weekday))
     }
 
     /// Find nth weekday in a month (e.g., 1st Monday, 2nd Tuesday, -1 = last)
-    fn find_nth_weekday_in_month(month_start: NaiveDate, position: i8, weekday: chrono::Weekday) -> Option<NaiveDate> {
+    fn find_nth_weekday_in_month(
+        month_start: NaiveDate,
+        position: i8,
+        weekday: chrono::Weekday,
+    ) -> Option<NaiveDate> {
         let year = month_start.year();
         let month = month_start.month();
-        
+
         if position > 0 {
             // Find nth occurrence from beginning of month
             let mut current = NaiveDate::from_ymd_opt(year, month, 1)?;
             let mut count = 0;
-            
+
             while current.month() == month {
                 if current.weekday() == weekday {
                     count += 1;
@@ -1612,7 +1827,7 @@ impl CalendarService {
             };
             let mut current = next_month.pred_opt()?; // Last day of current month
             let mut count = 0;
-            
+
             while current.month() == month {
                 if current.weekday() == weekday {
                     count += 1;
@@ -1623,9 +1838,7 @@ impl CalendarService {
                 current = current.pred_opt()?;
             }
         }
-        
+
         None
     }
-
 }
-
diff --git a/frontend/src/services/mod.rs b/frontend/src/services/mod.rs
index 0f69ad1..2ed91f3 100644
--- a/frontend/src/services/mod.rs
+++ b/frontend/src/services/mod.rs
@@ -1,3 +1,3 @@
 pub mod calendar_service;
 
-pub use calendar_service::CalendarService;
\ No newline at end of file
+pub use calendar_service::CalendarService;