Implement complete event editing functionality with backend update endpoint

Frontend Changes:
- Add edit context menu option to EventContextMenu with pencil icon
- Enhance CreateEventModal to support both create and edit modes
- Add event data conversion methods for pre-populating edit forms
- Implement conditional submit logic (on_create vs on_update callbacks)
- Add update_event method to CalendarService with POST /calendar/events/update

Backend Changes:
- Add UpdateEventRequest and UpdateEventResponse models
- Implement update_event handler with event search by UID across calendars
- Add POST /api/calendar/events/update route
- Full validation and parsing of all event properties for updates
- Integrate with existing CalDAV client update_event functionality

Users can now right-click events, select "Edit Event", modify properties in the modal, and successfully update existing events instead of creating duplicates.

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

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

src/components/create_event_modal.rs

@@ -1,14 +1,16 @@
 use yew::prelude::*;
 use web_sys::{HtmlInputElement, HtmlTextAreaElement, HtmlSelectElement};
 use chrono::{NaiveDate, NaiveTime};
-use crate::services::calendar_service::CalendarInfo;
+use crate::services::calendar_service::{CalendarInfo, CalendarEvent};
 
 #[derive(Properties, PartialEq)]
 pub struct CreateEventModalProps {
     pub is_open: bool,
     pub selected_date: Option<NaiveDate>,
+    pub event_to_edit: Option<CalendarEvent>,
     pub on_close: Callback<()>,
     pub on_create: Callback<EventCreationData>,
+    pub on_update: Callback<(CalendarEvent, EventCreationData)>, // (original_event, updated_data)
     pub available_calendars: Vec<CalendarInfo>,
 }
 
@@ -25,6 +27,16 @@ impl Default for EventStatus {
     }
 }
 
+impl EventStatus {
+    pub fn from_service_status(status: &crate::services::calendar_service::EventStatus) -> Self {
+        match status {
+            crate::services::calendar_service::EventStatus::Tentative => EventStatus::Tentative,
+            crate::services::calendar_service::EventStatus::Confirmed => EventStatus::Confirmed,
+            crate::services::calendar_service::EventStatus::Cancelled => EventStatus::Cancelled,
+        }
+    }
+}
+
 #[derive(Clone, PartialEq, Debug)]
 pub enum EventClass {
     Public,
@@ -38,6 +50,16 @@ impl Default for EventClass {
     }
 }
 
+impl EventClass {
+    pub fn from_service_class(class: &crate::services::calendar_service::EventClass) -> Self {
+        match class {
+            crate::services::calendar_service::EventClass::Public => EventClass::Public,
+            crate::services::calendar_service::EventClass::Private => EventClass::Private,
+            crate::services::calendar_service::EventClass::Confidential => EventClass::Confidential,
+        }
+    }
+}
+
 #[derive(Clone, PartialEq, Debug)]
 pub enum ReminderType {
     None,
@@ -71,6 +93,18 @@ impl Default for RecurrenceType {
     }
 }
 
+impl RecurrenceType {
+    pub fn from_rrule(rrule: Option<&str>) -> Self {
+        match rrule {
+            Some(rule) if rule.contains("FREQ=DAILY") => RecurrenceType::Daily,
+            Some(rule) if rule.contains("FREQ=WEEKLY") => RecurrenceType::Weekly,
+            Some(rule) if rule.contains("FREQ=MONTHLY") => RecurrenceType::Monthly,
+            Some(rule) if rule.contains("FREQ=YEARLY") => RecurrenceType::Yearly,
+            _ => RecurrenceType::None,
+        }
+    }
+}
+
 #[derive(Clone, PartialEq, Debug)]
 pub struct EventCreationData {
     pub title: String,
@@ -122,25 +156,56 @@ impl Default for EventCreationData {
     }
 }
 
+impl EventCreationData {
+    pub fn from_calendar_event(event: &CalendarEvent) -> Self {
+        // Convert CalendarEvent to EventCreationData for editing
+        Self {
+            title: event.summary.clone().unwrap_or_default(),
+            description: event.description.clone().unwrap_or_default(),
+            start_date: event.start.date_naive(),
+            start_time: event.start.time(),
+            end_date: event.end.as_ref().map(|e| e.date_naive()).unwrap_or(event.start.date_naive()),
+            end_time: event.end.as_ref().map(|e| e.time()).unwrap_or(event.start.time()),
+            location: event.location.clone().unwrap_or_default(),
+            all_day: event.all_day,
+            status: EventStatus::from_service_status(&event.status),
+            class: EventClass::from_service_class(&event.class),
+            priority: event.priority,
+            organizer: event.organizer.clone().unwrap_or_default(),
+            attendees: event.attendees.join(", "),
+            categories: event.categories.join(", "),
+            reminder: ReminderType::default(), // TODO: Convert from event reminders
+            recurrence: RecurrenceType::from_rrule(event.recurrence_rule.as_deref()),
+            recurrence_days: vec![false; 7], // TODO: Parse from RRULE
+            selected_calendar: event.calendar_path.clone(),
+        }
+    }
+}
+
 #[function_component(CreateEventModal)]
 pub fn create_event_modal(props: &CreateEventModalProps) -> Html {
     let event_data = use_state(|| EventCreationData::default());
     
-    // Initialize with selected date if provided
-    use_effect_with((props.selected_date, props.is_open, props.available_calendars.clone()), {
+    // 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()), {
         let event_data = event_data.clone();
-        move |(selected_date, is_open, available_calendars)| {
+        move |(selected_date, event_to_edit, is_open, available_calendars)| {
             if *is_open {
-                let mut data = if let Some(date) = selected_date {
-                    let mut data = (*event_data).clone();
+                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;
                     data
                 } else {
+                    // Default initialization
                     EventCreationData::default()
                 };
                 
-                // Set default calendar to the first available one
+                // 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());
                 }
@@ -401,11 +466,19 @@ pub fn create_event_modal(props: &CreateEventModalProps) -> Html {
         })
     };
 
-    let on_create_click = {
+    let on_submit_click = {
         let event_data = event_data.clone();
         let on_create = props.on_create.clone();
+        let on_update = props.on_update.clone();
+        let event_to_edit = props.event_to_edit.clone();
         Callback::from(move |_: MouseEvent| {
-            on_create.emit((*event_data).clone());
+            if let Some(original_event) = &event_to_edit {
+                // We're editing - call on_update with original event and new data
+                on_update.emit((original_event.clone(), (*event_data).clone()));
+            } else {
+                // We're creating - call on_create with new data
+                on_create.emit((*event_data).clone());
+            }
         })
     };
 
@@ -422,7 +495,7 @@ pub fn create_event_modal(props: &CreateEventModalProps) -> Html {
         <div class="modal-backdrop" onclick={on_backdrop_click}>
             <div class="modal-content create-event-modal" onclick={Callback::from(|e: MouseEvent| e.stop_propagation())}>
                 <div class="modal-header">
-                    <h3>{"Create New Event"}</h3>
+                    <h3>{if props.event_to_edit.is_some() { "Edit Event" } else { "Create New Event" }}</h3>
                     <button type="button" class="modal-close" onclick={Callback::from({
                         let on_close = props.on_close.clone();
                         move |_: MouseEvent| on_close.emit(())
@@ -707,10 +780,10 @@ pub fn create_event_modal(props: &CreateEventModalProps) -> Html {
                     <button 
                         type="button" 
                         class="btn btn-primary" 
-                        onclick={on_create_click}
+                        onclick={on_submit_click}
                         disabled={data.title.trim().is_empty()}
                     >
-                        {"Create Event"}
+                        {if props.event_to_edit.is_some() { "Update Event" } else { "Create Event" }}
                     </button>
                 </div>
             </div>