Refactor authentication from database to direct CalDAV authentication

Major architectural change to simplify authentication by authenticating directly against CalDAV servers instead of maintaining a local user database.

Backend changes:
- Remove SQLite database dependencies and user storage
- Refactor AuthService to authenticate directly against CalDAV servers
- Update JWT tokens to store CalDAV server info instead of user IDs
- Implement proper CalDAV calendar discovery with XML parsing
- Fix URL construction for CalDAV REPORT requests
- Add comprehensive debug logging for authentication flow

Frontend changes:
- Add server URL input field to login form
- Remove registration functionality entirely
- Update calendar service to pass CalDAV passwords via headers
- Store CalDAV credentials in localStorage for API calls

Key improvements:
- Simplified architecture eliminates database complexity
- Direct CalDAV authentication ensures credentials always work
- Proper calendar discovery automatically finds user calendars
- Robust error handling and debug logging for troubleshooting

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

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

src/components/login.rs

@@ -9,14 +9,24 @@ pub struct LoginProps {
 
 #[function_component]
 pub fn Login(props: &LoginProps) -> Html {
+    let server_url = use_state(String::new);
     let username = use_state(String::new);
     let password = use_state(String::new);
     let error_message = use_state(|| Option::<String>::None);
     let is_loading = use_state(|| false);
 
+    let server_url_ref = use_node_ref();
     let username_ref = use_node_ref();
     let password_ref = use_node_ref();
 
+    let on_server_url_change = {
+        let server_url = server_url.clone();
+        Callback::from(move |e: Event| {
+            let target = e.target_unchecked_into::<HtmlInputElement>();
+            server_url.set(target.value());
+        })
+    };
+
     let on_username_change = {
         let username = username.clone();
         Callback::from(move |e: Event| {
@@ -34,6 +44,7 @@ pub fn Login(props: &LoginProps) -> Html {
     };
 
     let on_submit = {
+        let server_url = server_url.clone();
         let username = username.clone();
         let password = password.clone();
         let error_message = error_message.clone();
@@ -43,6 +54,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();
             let error_message = error_message.clone();
@@ -50,7 +62,7 @@ pub fn Login(props: &LoginProps) -> Html {
             let on_login = on_login.clone();
 
             // Basic client-side validation
-            if username.trim().is_empty() || password.is_empty() {
+            if server_url.trim().is_empty() || username.trim().is_empty() || password.is_empty() {
                 error_message.set(Some("Please fill in all fields".to_string()));
                 return;
             }
@@ -59,19 +71,27 @@ pub fn Login(props: &LoginProps) -> Html {
             error_message.set(None);
 
             wasm_bindgen_futures::spawn_local(async move {
-                match perform_login(username, password).await {
-                    Ok(token) => {
-                        // Store token in local storage
+                web_sys::console::log_1(&"🚀 Starting login process...".into());
+                match perform_login(server_url.clone(), username.clone(), password.clone()).await {
+                    Ok((token, credentials)) => {
+                        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()));
                             is_loading.set(false);
                             return;
                         }
+                        if let Err(_) = LocalStorage::set("caldav_credentials", &credentials) {
+                            error_message.set(Some("Failed to store credentials".to_string()));
+                            is_loading.set(false);
+                            return;
+                        }
                         
                         is_loading.set(false);
                         on_login.emit(token);
                     }
                     Err(err) => {
+                        web_sys::console::log_1(&format!("❌ Login failed: {}", err).into());
                         error_message.set(Some(err));
                         is_loading.set(false);
                     }
@@ -83,8 +103,21 @@ pub fn Login(props: &LoginProps) -> Html {
     html! {
         <div class="login-container">
             <div class="login-form">
-                <h2>{"Sign In"}</h2>
+                <h2>{"Sign In to CalDAV"}</h2>
                 <form onsubmit={on_submit}>
+                    <div class="form-group">
+                        <label for="server_url">{"CalDAV Server URL"}</label>
+                        <input
+                            ref={server_url_ref}
+                            type="text"
+                            id="server_url"
+                            placeholder="https://your-caldav-server.com/dav/"
+                            value={(*server_url).clone()}
+                            onchange={on_server_url_change}
+                            disabled={*is_loading}
+                        />
+                    </div>
+
                     <div class="form-group">
                         <label for="username">{"Username"}</label>
                         <input
@@ -131,22 +164,43 @@ pub fn Login(props: &LoginProps) -> Html {
                 </form>
 
                 <div class="auth-links">
-                    <p>{"Don't have an account? "}<a href="/register">{"Sign up here"}</a></p>
+                    <p>{"Enter your CalDAV server credentials to connect to your calendar"}</p>
                 </div>
             </div>
         </div>
     }
 }
 
-/// Perform login using the auth service
-async fn perform_login(username: String, password: String) -> Result<String, String> {
-    use crate::auth::{AuthService, LoginRequest};
+/// Perform login using the CalDAV auth service
+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 = LoginRequest { username, password };
+    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) => Ok(response.token),
-        Err(err) => Err(err),
+        Ok(response) => {
+            web_sys::console::log_1(&format!("✅ Backend responded successfully").into());
+            // Create credentials object to store
+            let credentials = serde_json::json!({
+                "server_url": server_url,
+                "username": username,
+                "password": password
+            });
+            Ok((response.token, credentials.to_string()))
+        },
+        Err(err) => {
+            web_sys::console::log_1(&format!("❌ Backend error: {}", err).into());
+            Err(err)
+        },
     }
 }