Implement event deletion with right-click context menu

- Add EventContextMenu component with delete option
- Create DELETE /api/calendar/events/delete endpoint
- Implement CalDAV event deletion in backend
- Add proper URL construction for CalDAV event hrefs
- Integrate context menu with calendar event right-clicks
- Auto-refresh UI after successful event deletion

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

Co-Authored-By: Claude <noreply@anthropic.com>

backend/src/calendar.rs

@@ -694,6 +694,47 @@ impl CalDAVClient {
             Err(CalDAVError::ServerError(status.as_u16()))
         }
     }
+
+    /// Delete an event from a CalDAV calendar
+    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");
+            format!("{}{}", base_url, event_href)
+        } else {
+            // Event href is just a filename, combine with calendar path
+            let clean_path = if calendar_path.starts_with("/dav.php") {
+                calendar_path.trim_start_matches("/dav.php")
+            } else {
+                calendar_path
+            };
+            format!("{}/dav.php{}{}", self.config.server_url.trim_end_matches('/'), clean_path, event_href)
+        };
+        
+        println!("Deleting event at: {}", full_url);
+        
+        let response = self.http_client
+            .delete(&full_url)
+            .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(())
+        } else {
+            let status = response.status();
+            let error_body = response.text().await.unwrap_or_default();
+            println!("❌ Event deletion failed: {} - {}", status, error_body);
+            Err(CalDAVError::ServerError(status.as_u16()))
+        }
+    }
 }
 
 /// Helper struct for extracting calendar data from XML responses

backend/src/handlers.rs

@@ -7,7 +7,7 @@ use serde::Deserialize;
 use std::sync::Arc;
 use chrono::Datelike;
 
-use crate::{AppState, models::{CalDAVLoginRequest, AuthResponse, ApiError, UserInfo, CalendarInfo, CreateCalendarRequest, CreateCalendarResponse, DeleteCalendarRequest, DeleteCalendarResponse}};
+use crate::{AppState, models::{CalDAVLoginRequest, AuthResponse, ApiError, UserInfo, CalendarInfo, CreateCalendarRequest, CreateCalendarResponse, DeleteCalendarRequest, DeleteCalendarResponse, DeleteEventRequest, DeleteEventResponse}};
 use crate::calendar::{CalDAVClient, CalendarEvent};
 
 #[derive(Deserialize)]
@@ -323,4 +323,38 @@ pub async fn delete_calendar(
         success: true,
         message: "Calendar deleted successfully".to_string(),
     }))
+}
+
+pub async fn delete_event(
+    State(state): State<Arc<AppState>>,
+    headers: HeaderMap,
+    Json(request): Json<DeleteEventRequest>,
+) -> Result<Json<DeleteEventResponse>, ApiError> {
+    println!("🗑️ Delete event request received: calendar_path='{}', event_href='{}'", request.calendar_path, request.event_href);
+    
+    // Extract and verify token
+    let token = extract_bearer_token(&headers)?;
+    let password = extract_password_header(&headers)?;
+
+    // Validate request
+    if request.calendar_path.trim().is_empty() {
+        return Err(ApiError::BadRequest("Calendar path is required".to_string()));
+    }
+    if request.event_href.trim().is_empty() {
+        return Err(ApiError::BadRequest("Event href is required".to_string()));
+    }
+
+    // Create CalDAV config from token and password
+    let config = state.auth_service.caldav_config_from_token(&token, &password)?;
+    let client = CalDAVClient::new(config);
+
+    // Delete the event
+    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(),
+    }))
 }

backend/src/lib.rs

@@ -41,6 +41,7 @@ pub async fn run_server() -> Result<(), Box<dyn std::error::Error>> {
         .route("/api/calendar/create", post(handlers::create_calendar))
         .route("/api/calendar/delete", post(handlers::delete_calendar))
         .route("/api/calendar/events", get(handlers::get_calendar_events))
+        .route("/api/calendar/events/delete", post(handlers::delete_event))
         .route("/api/calendar/events/:uid", get(handlers::refresh_event))
         .layer(
             CorsLayer::new()

backend/src/models.rs

@@ -58,6 +58,18 @@ pub struct DeleteCalendarResponse {
     pub message: String,
 }
 
+#[derive(Debug, Deserialize)]
+pub struct DeleteEventRequest {
+    pub calendar_path: String,
+    pub event_href: String,
+}
+
+#[derive(Debug, Serialize)]
+pub struct DeleteEventResponse {
+    pub success: bool,
+    pub message: String,
+}
+
 // Error handling
 #[derive(Debug)]
 pub enum ApiError {