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

Implement calendar deletion with right-click context menu

Browse Source 
Added complete calendar deletion functionality including:
- Context menu component with right-click activation on calendar items
- Backend API endpoint for calendar deletion with CalDAV DELETE method
- Frontend integration with calendar list refresh after deletion
- Fixed URL construction to prevent double /dav.php path issue
- Added proper error handling and user feedback

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

Co-Authored-By: Claude <noreply@anthropic.com>
This commit is contained in:
Connor Johnstone
2025-08-28 21:31:58 -04:00
parent f9c87369e5
commit c454104c69
9 changed files with 341 additions and 5 deletions
Download Patch File Download Diff File Expand all files Collapse all files

36
backend/src/calendar.rs
View File

@@ -658,6 +658,42 @@ impl CalDAVClient {
Err(CalDAVError::ServerError(status.as_u16()))
}
}
/// Delete a calendar from the CalDAV server
pub async fn delete_calendar(&self, calendar_path: &str) -> Result<(), CalDAVError> {
let full_url = if calendar_path.starts_with("http") {
calendar_path.to_string()
} else {
// Handle case where calendar_path already contains /dav.php
let clean_path = if calendar_path.starts_with("/dav.php") {
calendar_path.trim_start_matches("/dav.php")
} else {
calendar_path
};
format!("{}{}", self.config.server_url.trim_end_matches('/'), clean_path)
};
println!("Deleting calendar 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!("Calendar deletion response status: {}", response.status());
if response.status().is_success() || response.status().as_u16() == 204 {
println!("✅ Calendar deleted successfully at {}", calendar_path);
Ok(())
} else {
let status = response.status();
let error_body = response.text().await.unwrap_or_default();
println!("❌ Calendar deletion failed: {} - {}", status, error_body);
Err(CalDAVError::ServerError(status.as_u16()))
}
}
}
/// Helper struct for extracting calendar data from XML responses

33
backend/src/handlers.rs
View File

@@ -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}};
use crate::{AppState, models::{CalDAVLoginRequest, AuthResponse, ApiError, UserInfo, CalendarInfo, CreateCalendarRequest, CreateCalendarResponse, DeleteCalendarRequest, DeleteCalendarResponse}};
use crate::calendar::{CalDAVClient, CalendarEvent};
#[derive(Deserialize)]
@@ -292,4 +292,35 @@ pub async fn create_calendar(
success: true,
message: "Calendar created successfully".to_string(),
}))
}
pub async fn delete_calendar(
State(state): State<Arc<AppState>>,
headers: HeaderMap,
Json(request): Json<DeleteCalendarRequest>,
) -> Result<Json<DeleteCalendarResponse>, ApiError> {
println!("🗑️ Delete calendar request received: path='{}'", request.path);
// Extract and verify token
let token = extract_bearer_token(&headers)?;
let password = extract_password_header(&headers)?;
// Validate request
if request.path.trim().is_empty() {
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 client = CalDAVClient::new(config);
// Delete the calendar
client.delete_calendar(&request.path)
.await
.map_err(|e| ApiError::Internal(format!("Failed to delete calendar: {}", e)))?;
Ok(Json(DeleteCalendarResponse {
success: true,
message: "Calendar deleted successfully".to_string(),
}))
}

1
backend/src/lib.rs
View File

@@ -39,6 +39,7 @@ pub async fn run_server() -> Result<(), Box<dyn std::error::Error>> {
.route("/api/auth/verify", get(handlers::verify_token))
.route("/api/user/info", get(handlers::get_user_info))
.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/:uid", get(handlers::refresh_event))
.layer(

11
backend/src/models.rs
View File

@@ -47,6 +47,17 @@ pub struct CreateCalendarResponse {
pub message: String,
}
#[derive(Debug, Deserialize)]
pub struct DeleteCalendarRequest {
pub path: String,
}
#[derive(Debug, Serialize)]
pub struct DeleteCalendarResponse {
pub success: bool,
pub message: String,
}
// Error handling
#[derive(Debug)]
pub enum ApiError {

93
src/app.rs
View File

@@ -1,7 +1,7 @@
use yew::prelude::*;
use yew_router::prelude::*;
use gloo_storage::{LocalStorage, Storage};
use crate::components::{Login, Calendar, CreateCalendarModal};
use crate::components::{Login, Calendar, CreateCalendarModal, ContextMenu};
use crate::services::{CalendarService, CalendarEvent, UserInfo};
use std::collections::HashMap;
use chrono::{Local, NaiveDate, Datelike};
@@ -25,6 +25,9 @@ pub fn App() -> Html {
let user_info = use_state(|| -> Option<UserInfo> { None });
let color_picker_open = use_state(|| -> Option<String> { None }); // Store calendar path of open picker
let create_modal_open = use_state(|| false);
let context_menu_open = use_state(|| false);
let context_menu_pos = use_state(|| (0i32, 0i32));
let context_menu_calendar_path = use_state(|| -> Option<String> { None });
// Available colors for calendar customization
let available_colors = [
@@ -109,15 +112,20 @@ pub fn App() -> Html {
let on_outside_click = {
let color_picker_open = color_picker_open.clone();
let context_menu_open = context_menu_open.clone();
Callback::from(move |_: MouseEvent| {
color_picker_open.set(None);
context_menu_open.set(false);
})
};
// Clone variables needed for the modal outside of the conditional blocks
// Clone variables needed for the modal and context menu outside of the conditional blocks
let auth_token_for_modal = auth_token.clone();
let user_info_for_modal = user_info.clone();
let create_modal_open_for_modal = create_modal_open.clone();
let auth_token_for_context = auth_token.clone();
let user_info_for_context = user_info.clone();
let context_menu_calendar_path_for_context = context_menu_calendar_path.clone();
html! {
<BrowserRouter>
@@ -165,9 +173,22 @@ pub fn App() -> Html {
color_picker_open.set(Some(cal_path.clone()));
})
};
let on_context_menu = {
let cal_path = cal.path.clone();
let context_menu_open = context_menu_open.clone();
let context_menu_pos = context_menu_pos.clone();
let context_menu_calendar_path = context_menu_calendar_path.clone();
Callback::from(move |e: MouseEvent| {
e.prevent_default();
context_menu_open.set(true);
context_menu_pos.set((e.client_x(), e.client_y()));
context_menu_calendar_path.set(Some(cal_path.clone()));
})
};
html! {
<li key={cal.path.clone()}>
<li key={cal.path.clone()} oncontextmenu={on_context_menu}>
<span class="calendar-color"
style={format!("background-color: {}", cal.color)}
onclick={on_color_click}>
@@ -379,6 +400,72 @@ pub fn App() -> Html {
})}
available_colors={available_colors.iter().map(|c| c.to_string()).collect::<Vec<_>>()}
/>
<ContextMenu
is_open={*context_menu_open}
x={context_menu_pos.0}
y={context_menu_pos.1}
on_close={Callback::from({
let context_menu_open = context_menu_open.clone();
move |_| context_menu_open.set(false)
})}
on_delete={Callback::from({
let auth_token = auth_token_for_context.clone();
let user_info = user_info_for_context.clone();
let context_menu_calendar_path = context_menu_calendar_path_for_context.clone();
move |_: MouseEvent| {
if let (Some(token), Some(calendar_path)) = ((*auth_token).clone(), (*context_menu_calendar_path).clone()) {
let user_info = user_info.clone();
wasm_bindgen_futures::spawn_local(async move {
let calendar_service = CalendarService::new();
// Get password from stored credentials
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.delete_calendar(&token, &password, calendar_path).await {
Ok(_) => {
web_sys::console::log_1(&"Calendar deleted successfully!".into());
// Refresh user info to remove the deleted calendar
match calendar_service.fetch_user_info(&token, &password).await {
Ok(mut info) => {
// Load saved colors from local storage
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 {
cal.color = saved_cal.color.clone();
}
}
}
}
}
user_info.set(Some(info));
}
Err(err) => {
web_sys::console::log_1(&format!("Failed to refresh calendars: {}", err).into());
}
}
}
Err(err) => {
web_sys::console::log_1(&format!("Failed to delete calendar: {}", err).into());
// TODO: Show error to user
}
}
});
}
}
})}
/>
</div>
</BrowserRouter>
}

49
src/components/context_menu.rs Normal file
View File

@@ -0,0 +1,49 @@
use yew::prelude::*;
use web_sys::MouseEvent;
#[derive(Properties, PartialEq)]
pub struct ContextMenuProps {
pub is_open: bool,
pub x: i32,
pub y: i32,
pub on_delete: Callback<MouseEvent>,
pub on_close: Callback<()>,
}
#[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 {
return html! {};
}
let style = format!(
"position: fixed; left: {}px; top: {}px; z-index: 1001;",
props.x, props.y
);
let on_delete_click = {
let on_delete = props.on_delete.clone();
let on_close = props.on_close.clone();
Callback::from(move |e: MouseEvent| {
on_delete.emit(e);
on_close.emit(());
})
};
html! {
<div
ref={menu_ref}
class="context-menu"
style={style}
>
<div class="context-menu-item context-menu-delete" onclick={on_delete_click}>
<span class="context-menu-icon">{"🗑️"}</span>
{"Delete Calendar"}
</div>
</div>
}
}

4
src/components/mod.rs
View File

@@ -2,8 +2,10 @@ pub mod login;
pub mod calendar;
pub mod event_modal;
pub mod create_calendar_modal;
pub mod context_menu;
pub use login::Login;
pub use calendar::Calendar;
pub use event_modal::EventModal;
pub use create_calendar_modal::CreateCalendarModal;
pub use create_calendar_modal::CreateCalendarModal;
pub use context_menu::ContextMenu;

57
src/services/calendar_service.rs
View File

@@ -528,6 +528,63 @@ impl CalendarService {
}
}
/// Delete a calendar from the CalDAV server
pub async fn delete_calendar(
&self,
token: &str,
password: &str,
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);
let body = serde_json::json!({
"path": path
});
let body_string = serde_json::to_string(&body)
.map_err(|e| format!("JSON serialization failed: {}", e))?;
opts.set_body(&body_string.into());
let url = format!("{}/calendar/delete", self.base_url);
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))
.map_err(|e| format!("Authorization header setting failed: {:?}", e))?;
request.headers().set("X-CalDAV-Password", password)
.map_err(|e| format!("Password header setting failed: {:?}", e))?;
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()
.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_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))
}
}
/// 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> {
let window = web_sys::window().ok_or("No global window exists")?;

62
styles.css
View File

@@ -1107,4 +1107,66 @@ body {
width: 100%;
text-align: center;
}
}
/* Context Menu */
.context-menu {
background: white;
border: 1px solid #e9ecef;
border-radius: 8px;
box-shadow: 0 4px 12px rgba(0, 0, 0, 0.15);
min-width: 160px;
overflow: hidden;
animation: contextMenuSlideIn 0.15s ease;
}
@keyframes contextMenuSlideIn {
from {
opacity: 0;
transform: scale(0.95) translateY(-5px);
}
to {
opacity: 1;
transform: scale(1) translateY(0);
}
}
.context-menu-item {
display: flex;
align-items: center;
padding: 0.75rem 1rem;
color: #495057;
cursor: pointer;
transition: background-color 0.2s ease;
font-size: 0.9rem;
border: none;
background: none;
width: 100%;
text-align: left;
}
.context-menu-item:hover {
background-color: #f8f9fa;
}
.context-menu-delete {
color: #dc3545;
}
.context-menu-delete:hover {
background-color: #f8f9fa;
color: #dc3545;
}
.context-menu-icon {
margin-right: 0.5rem;
font-size: 1rem;
}
/* Prevent text selection on context menu items */
.context-menu-item {
user-select: none;
-webkit-user-select: none;
-moz-user-select: none;
-ms-user-select: none;
}