Update dependencies and UI for WASM compatibility

- Simplify Cargo.toml dependencies for frontend-only build - Add comprehensive CSS styling with responsive design - Update app routing and main module structure - Fix WASM getrandom compatibility with js feature 🤖 Generated with [Claude Code](https://claude.ai/code) Co-Authored-By: Claude <noreply@anthropic.com>
Implement frontend authentication system with login/registration
2025-08-28 15:56:41 -04:00 · 2025-08-28 15:56:18 -04:00 · 2025-08-28 15:30:47 -04:00
9 changed files with 1529 additions and 22 deletions
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -10,8 +10,6 @@ wasm-bindgen = "0.2"
 # HTTP client for CalDAV requests
 reqwest = { version = "0.11", features = ["json"] }
 wasm-bindgen-futures = "0.4"
 # Calendar and iCal parsing
 ical = "0.7"
 serde = { version = "1.0", features = ["derive"] }
@@ -30,11 +28,26 @@ log = "0.4"
 console_log = "1.0"
 # UUID generation for calendar events
-uuid = { version = "1.0", features = ["v4", "wasm-bindgen"] }
+uuid = { version = "1.0", features = ["v4", "wasm-bindgen", "serde"] }
 getrandom = { version = "0.2", features = ["js"] }
 # Environment variable handling
 dotenvy = "0.15"
 base64 = "0.21"
 # XML/Regex parsing
 regex = "1.0"
 # Frontend authentication (backend removed for WASM compatibility)
 # sqlx = { version = "0.7", features = ["runtime-tokio-rustls", "sqlite", "chrono", "uuid", "migrate"] }
 # bcrypt = "0.15"
 # jsonwebtoken = "9.0"
 # Yew routing and local storage
 yew-router = "0.18"
 gloo-storage = "0.3"
 gloo-timers = "0.3"
 wasm-bindgen-futures = "0.4"
 [dev-dependencies]
 tokio = { version = "1.0", features = ["macros", "rt"] }
--- a/index.html
+++ b/index.html
@@ -2,38 +2,260 @@
 <html>
 <head>
    <meta charset="utf-8" />
-    <title>Yew App</title>
+    <title>Calendar App</title>
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <style>
-        body {
+        * {
            font-family: Arial, sans-serif;
            margin: 0;
-            padding: 20px;
+            padding: 0;
-            background-color: #f5f5f5;
+            box-sizing: border-box;
        }
-        div {
+
-            max-width: 600px;
+        body {
            font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
            background-color: #f8f9fa;
            color: #333;
            line-height: 1.6;
        }
        .app {
            min-height: 100vh;
            display: flex;
            flex-direction: column;
        }
        .app-header {
            background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
            color: white;
            padding: 1rem 2rem;
            display: flex;
            justify-content: space-between;
            align-items: center;
            box-shadow: 0 2px 4px rgba(0,0,0,0.1);
        }
        .app-header h1 {
            margin: 0;
            font-size: 1.8rem;
        }
        .app-header nav {
            display: flex;
            gap: 1rem;
            align-items: center;
        }
        .app-header nav a {
            color: white;
            text-decoration: none;
            padding: 0.5rem 1rem;
            border-radius: 4px;
            transition: background-color 0.2s;
        }
        .app-header nav a:hover {
            background-color: rgba(255,255,255,0.2);
        }
        .app-main {
            flex: 1;
            padding: 2rem;
            max-width: 1200px;
            margin: 0 auto;
-            padding: 20px;
+            width: 100%;
-            background-color: white;
+        }
        /* Authentication Forms */
        .login-container, .register-container {
            display: flex;
            justify-content: center;
            align-items: center;
            min-height: 60vh;
        }
        .login-form, .register-form {
            background: white;
            padding: 2rem;
            border-radius: 8px;
            box-shadow: 0 4px 6px rgba(0,0,0,0.1);
            width: 100%;
            max-width: 400px;
        }
        .login-form h2, .register-form h2 {
            text-align: center;
            margin-bottom: 2rem;
            color: #333;
        }
        .form-group {
            margin-bottom: 1.5rem;
        }
        .form-group label {
            display: block;
            margin-bottom: 0.5rem;
            font-weight: 500;
            color: #555;
        }
        .form-group input {
            width: 100%;
            padding: 0.75rem;
            border: 1px solid #ddd;
            border-radius: 4px;
            font-size: 1rem;
            transition: border-color 0.2s;
        }
        .form-group input:focus {
            outline: none;
            border-color: #667eea;
            box-shadow: 0 0 0 2px rgba(102, 126, 234, 0.2);
        }
        .form-group input:disabled {
            background-color: #f5f5f5;
            cursor: not-allowed;
        }
        .login-button, .register-button {
            width: 100%;
            padding: 0.75rem;
            background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
            color: white;
            border: none;
            border-radius: 4px;
            font-size: 1rem;
            font-weight: 500;
            cursor: pointer;
            transition: transform 0.2s, box-shadow 0.2s;
        }
        .login-button:hover, .register-button:hover {
            transform: translateY(-1px);
            box-shadow: 0 4px 8px rgba(0,0,0,0.2);
        }
        .login-button:disabled, .register-button:disabled {
            background: #ccc;
            transform: none;
            cursor: not-allowed;
        }
        .error-message {
            background-color: #f8d7da;
            color: #721c24;
            padding: 0.75rem;
            border-radius: 4px;
            margin-bottom: 1rem;
            border: 1px solid #f5c6cb;
        }
        .auth-links {
            text-align: center;
            margin-top: 2rem;
            color: #666;
        }
        .auth-links a {
            color: #667eea;
            text-decoration: none;
        }
        .auth-links a:hover {
            text-decoration: underline;
        }
        .logout-button {
            background: rgba(255,255,255,0.2);
            border: 1px solid rgba(255,255,255,0.3);
            color: white;
            padding: 0.5rem 1rem;
            border-radius: 4px;
            cursor: pointer;
            transition: background-color 0.2s;
        }
        .logout-button:hover {
            background: rgba(255,255,255,0.3);
        }
        /* Calendar View */
        .calendar-view {
            background: white;
            padding: 2rem;
            border-radius: 8px;
            box-shadow: 0 2px 4px rgba(0,0,0,0.1);
        }
-        h1 {
+
        .calendar-view h2 {
            color: #333;
            margin-bottom: 1rem;
        }
        .demo-section {
            margin: 2rem 0;
            padding: 1rem;
            background: #f8f9fa;
            border-radius: 4px;
            border-left: 4px solid #667eea;
        }
        .demo-section h3 {
            margin-bottom: 1rem;
            color: #333;
        }
-        button {
+
        .demo-section button {
            background-color: #007bff;
            color: white;
            border: none;
-            padding: 10px 20px;
+            padding: 0.5rem 1rem;
            border-radius: 4px;
            cursor: pointer;
-            font-size: 16px;
+            margin-right: 1rem;
        }
-        button:hover {
+
        .demo-section button:hover {
            background-color: #0056b3;
        }
        .calendar-placeholder {
            margin-top: 2rem;
            padding: 1rem;
            background: #e9ecef;
            border-radius: 4px;
        }
        .calendar-placeholder ul {
            margin: 1rem 0;
            padding-left: 2rem;
        }
        .calendar-placeholder li {
            margin: 0.5rem 0;
        }
        @media (max-width: 768px) {
            .app-header {
                flex-direction: column;
                text-align: center;
                padding: 1rem;
            }
            .app-header nav {
                margin-top: 1rem;
            }
            .app-main {
                padding: 1rem;
            }
            .login-form, .register-form {
                padding: 1.5rem;
            }
        }
    </style>
 </head>
 <body></body>
--- a/src/app.rs
+++ b/src/app.rs
@@ -1,7 +1,109 @@
 use yew::prelude::*;
 use yew_router::prelude::*;
 use gloo_storage::{LocalStorage, Storage};
 use crate::components::{Login, Register};
 #[derive(Clone, Routable, PartialEq)]
 enum Route {
    #[at("/")]
    Home,
    #[at("/login")]
    Login,
    #[at("/register")]
    Register,
    #[at("/calendar")]
    Calendar,
 }
 #[function_component]
 pub fn App() -> Html {
    let auth_token = use_state(|| -> Option<String> {
        LocalStorage::get("auth_token").ok()
    });
    let on_login = {
        let auth_token = auth_token.clone();
        Callback::from(move |token: String| {
            auth_token.set(Some(token));
        })
    };
    let on_logout = {
        let auth_token = auth_token.clone();
        Callback::from(move |_| {
            let _ = LocalStorage::delete("auth_token");
            auth_token.set(None);
        })
    };
    html! {
        <BrowserRouter>
            <div class="app">
                <header class="app-header">
                    <h1>{"Calendar App"}</h1>
                    {
                        if auth_token.is_some() {
                            html! {
                                <nav>
                                    <Link<Route> to={Route::Calendar}>{"Calendar"}</Link<Route>>
                                    <button onclick={on_logout} class="logout-button">{"Logout"}</button>
                                </nav>
                            }
                        } else {
                            html! {
                                <nav>
                                    <Link<Route> to={Route::Login}>{"Login"}</Link<Route>>
                                    <Link<Route> to={Route::Register}>{"Register"}</Link<Route>>
                                </nav>
                            }
                        }
                    }
                </header>
                <main class="app-main">
                    <Switch<Route> render={move |route| {
                        let auth_token = (*auth_token).clone();
                        let on_login = on_login.clone();
                        match route {
                            Route::Home => {
                                if auth_token.is_some() {
                                    html! { <Redirect<Route> to={Route::Calendar}/> }
                                } else {
                                    html! { <Redirect<Route> to={Route::Login}/> }
                                }
                            }
                            Route::Login => {
                                if auth_token.is_some() {
                                    html! { <Redirect<Route> to={Route::Calendar}/> }
                                } else {
                                    html! { <Login {on_login} /> }
                                }
                            }
                            Route::Register => {
                                if auth_token.is_some() {
                                    html! { <Redirect<Route> to={Route::Calendar}/> }
                                } else {
                                    html! { <Register on_register={on_login.clone()} /> }
                                }
                            }
                            Route::Calendar => {
                                if auth_token.is_some() {
                                    html! { <CalendarView /> }
                                } else {
                                    html! { <Redirect<Route> to={Route::Login}/> }
                                }
                            }
                        }
                    }} />
                </main>
            </div>
        </BrowserRouter>
    }
 }
 #[function_component]
 fn CalendarView() -> Html {
    let counter = use_state(|| 0);
    let onclick = {
        let counter = counter.clone();
@@ -12,13 +114,27 @@ pub fn App() -> Html {
    };
    html! {
-        <div>
+        <div class="calendar-view">
-            <h1>{ "Hello Yew!" }</h1>
+            <h2>{"Welcome to your Calendar!"}</h2>
-            <p>{ "This is a basic Yew application template." }</p>
+            <p>{"You are now authenticated and can access your calendar."}</p>
-            <div>
+            
            // Temporary counter demo - will be replaced with calendar functionality
            <div class="demo-section">
                <h3>{"Demo Counter"}</h3>
                <button {onclick}>{ "Click me!" }</button>
                <p>{ format!("Counter: {}", *counter) }</p>
            </div>
            <div class="calendar-placeholder">
                <p>{"Calendar functionality will be implemented here."}</p>
                <p>{"This will include:"}</p>
                <ul>
                    <li>{"Calendar view with events"}</li>
                    <li>{"Integration with CalDAV server"}</li>
                    <li>{"Event creation and editing"}</li>
                    <li>{"Synchronization with Baikal server"}</li>
                </ul>
            </div>
        </div>
    }
 }
--- a/src/auth.rs
+++ b/src/auth.rs
@@ -0,0 +1,123 @@
 // Frontend-only authentication module (simplified for WASM compatibility)
 use serde::{Deserialize, Serialize};
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct User {
    pub id: String,
    pub username: String,
    pub email: String,
 }
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct UserInfo {
    pub id: String,
    pub username: String,
    pub email: String,
 }
 #[derive(Debug, Serialize, Deserialize)]
 pub struct RegisterRequest {
    pub username: String,
    pub email: String,
    pub password: String,
 }
 #[derive(Debug, Serialize, Deserialize)]
 pub struct LoginRequest {
    pub username: String,
    pub password: String,
 }
 #[derive(Debug, Serialize, Deserialize)]
 pub struct AuthResponse {
    pub token: String,
    pub user: UserInfo,
 }
 // Simplified frontend-only auth service
 pub struct AuthService;
 impl AuthService {
    pub fn new() -> Self {
        Self
    }
    // Mock authentication methods for development
    // In production, these would make HTTP requests to a backend API
    pub async fn register(&self, request: RegisterRequest) -> Result<AuthResponse, String> {
        // Simulate API delay
        gloo_timers::future::TimeoutFuture::new(500).await;
        // Basic validation
        if request.username.trim().is_empty() || request.email.trim().is_empty() || request.password.is_empty() {
            return Err("All fields are required".to_string());
        }
        if request.password.len() < 6 {
            return Err("Password must be at least 6 characters".to_string());
        }
        // Mock successful registration
        Ok(AuthResponse {
            token: format!("mock-jwt-token-{}", request.username),
            user: UserInfo {
                id: "user-123".to_string(),
                username: request.username,
                email: request.email,
            },
        })
    }
    pub async fn login(&self, request: LoginRequest) -> Result<AuthResponse, String> {
        // Simulate API delay
        gloo_timers::future::TimeoutFuture::new(500).await;
        // Basic validation
        if request.username.trim().is_empty() || request.password.is_empty() {
            return Err("Username and password are required".to_string());
        }
        // Mock authentication - accept demo/password or any user/password combo
        if request.username == "demo" && request.password == "password" {
            Ok(AuthResponse {
                token: "mock-jwt-token-demo".to_string(),
                user: UserInfo {
                    id: "demo-user-123".to_string(),
                    username: request.username,
                    email: "demo@example.com".to_string(),
                },
            })
        } else if !request.password.is_empty() {
            // Accept any non-empty password for development
            let username = request.username.clone();
            Ok(AuthResponse {
                token: format!("mock-jwt-token-{}", username),
                user: UserInfo {
                    id: format!("user-{}", username),
                    username: request.username,
                    email: format!("{}@example.com", username),
                },
            })
        } else {
            Err("Invalid credentials".to_string())
        }
    }
    pub async fn verify_token(&self, token: &str) -> Result<UserInfo, String> {
        // Simulate API delay
        gloo_timers::future::TimeoutFuture::new(100).await;
        // Mock token verification
        if token.starts_with("mock-jwt-token-") {
            let username = token.strip_prefix("mock-jwt-token-").unwrap_or("unknown");
            Ok(UserInfo {
                id: format!("user-{}", username),
                username: username.to_string(),
                email: format!("{}@example.com", username),
            })
        } else {
            Err("Invalid token".to_string())
        }
    }
 }
--- a/src/calendar.rs
+++ b/src/calendar.rs
@@ -0,0 +1,639 @@
 use chrono::{DateTime, Utc};
 use serde::{Deserialize, Serialize};
 use std::collections::HashMap;
 /// Represents a calendar event with all its properties
 #[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
 pub struct CalendarEvent {
    /// 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>,
    /// All-day event flag
    pub all_day: bool,
    /// ETag from CalDAV server for conflict detection
    pub etag: Option<String>,
    /// URL/href of this event on the CalDAV server
    pub href: Option<String>,
 }
 /// Event status enumeration
 #[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
 pub enum EventStatus {
    Tentative,
    Confirmed,
    Cancelled,
 }
 impl Default for EventStatus {
    fn default() -> Self {
        EventStatus::Confirmed
    }
 }
 /// Event classification enumeration
 #[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
 pub enum EventClass {
    Public,
    Private,
    Confidential,
 }
 impl Default for EventClass {
    fn default() -> Self {
        EventClass::Public
    }
 }
 /// CalDAV client for fetching and parsing calendar events
 pub struct CalDAVClient {
    config: crate::config::CalDAVConfig,
    http_client: reqwest::Client,
 }
 impl CalDAVClient {
    /// Create a new CalDAV client with the given configuration
    pub fn new(config: crate::config::CalDAVConfig) -> Self {
        Self {
            config,
            http_client: reqwest::Client::new(),
        }
    }
    /// 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> {
        // 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">
    <d:prop>
        <d:getetag/>
        <c:calendar-data/>
    </d:prop>
    <c:filter>
        <c:comp-filter name="VCALENDAR">
            <c:comp-filter name="VEVENT"/>
        </c:comp-filter>
    </c:filter>
 </c:calendar-query>"#;
        let url = if calendar_path.starts_with("http") {
            calendar_path.to_string()
        } else {
            format!("{}{}", self.config.server_url.trim_end_matches('/'), calendar_path)
        };
        let response = self.http_client
            .request(reqwest::Method::from_bytes(b"REPORT").unwrap(), &url)
            .header("Authorization", format!("Basic {}", self.config.get_basic_auth()))
            .header("Content-Type", "application/xml")
            .header("Depth", "1")
            .header("User-Agent", "calendar-app/0.1.0")
            .body(report_body)
            .send()
            .await
            .map_err(CalDAVError::RequestError)?;
        if !response.status().is_success() && response.status().as_u16() != 207 {
            return Err(CalDAVError::ServerError(response.status().as_u16()));
        }
        let body = response.text().await.map_err(CalDAVError::RequestError)?;
        self.parse_calendar_response(&body)
    }
    /// Parse CalDAV XML response containing calendar data
    fn parse_calendar_response(&self, xml_response: &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 {
                    event.etag = calendar_data.etag.clone();
                    event.href = calendar_data.href.clone();
                    events.push(event);
                }
            }
        }
        Ok(events)
    }
    /// 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, "calendar-data") {
                    sections.push(CalendarDataSection {
                        href: if href.is_empty() { None } else { Some(href) },
                        etag: if etag.is_empty() { None } else { Some(etag) },
                        data: calendar_data,
                    });
                }
            }
        }
        sections
    }
    /// Extract content from XML tags (simple implementation)
    fn extract_xml_content(&self, xml: &str, tag: &str) -> Option<String> {
        // Handle both with and without namespace prefixes
        let patterns = [
            format!("<{}>(.*?)</{}>", tag, tag),
            format!("<{}>(.*?)</.*:{}>", tag, tag),
            format!("<.*:{}>(.*?)</{}>", tag, tag),
            format!("<.*:{}>(.*?)</.*:{}>", tag, tag),
        ];
        for pattern in &patterns {
            if let Ok(re) = regex::Regex::new(pattern) {
                if let Some(captures) = re.captures(xml) {
                    if let Some(content) = captures.get(1) {
                        return Some(content.as_str().trim().to_string());
                    }
                }
            }
        }
        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> {
        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.unwrap_or_default());
        }
        // Required UID field
        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")
            .ok_or_else(|| CalDAVError::ParseError("Missing DTSTART field".to_string()))?;
        let start = self.parse_datetime(start, properties.get("DTSTART"))?;
        // Parse end time (optional - use start time if not present)
        let end = if let Some(dtend) = properties.get("DTEND") {
            Some(self.parse_datetime(dtend, properties.get("DTEND"))?)
        } else if let Some(duration) = properties.get("DURATION") {
            // TODO: Parse duration and add to start time
            Some(start)
        } else {
            None
        };
        // Determine if it's an all-day event
        let all_day = properties.get("DTSTART")
            .map(|s| !s.contains("T"))
            .unwrap_or(false);
        // Parse status
        let status = properties.get("STATUS")
            .map(|s| match s.to_uppercase().as_str() {
                "TENTATIVE" => EventStatus::Tentative,
                "CANCELLED" => EventStatus::Cancelled,
                _ => EventStatus::Confirmed,
            })
            .unwrap_or_default();
        // Parse classification
        let class = properties.get("CLASS")
            .map(|s| match s.to_uppercase().as_str() {
                "PRIVATE" => EventClass::Private,
                "CONFIDENTIAL" => EventClass::Confidential,
                _ => EventClass::Public,
            })
            .unwrap_or_default();
        // Parse priority
        let priority = properties.get("PRIORITY")
            .and_then(|s| s.parse::<u8>().ok())
            .filter(|&p| p <= 9);
        // Parse 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")
            .and_then(|s| self.parse_datetime(s, None).ok());
        let last_modified = properties.get("LAST-MODIFIED")
            .and_then(|s| self.parse_datetime(s, None).ok());
        Ok(CalendarEvent {
            uid,
            summary: properties.get("SUMMARY").cloned(),
            description: properties.get("DESCRIPTION").cloned(),
            start,
            end,
            location: properties.get("LOCATION").cloned(),
            status,
            class,
            priority,
            organizer: properties.get("ORGANIZER").cloned(),
            attendees: Vec::new(), // TODO: Parse attendees
            categories,
            created,
            last_modified,
            recurrence_rule: properties.get("RRULE").cloned(),
            all_day,
            etag: None, // Set by caller
            href: None, // Set by caller
        })
    }
    /// Discover available calendar collections on the server
    pub async fn discover_calendars(&self) -> Result<Vec<String>, CalDAVError> {
        // First, try to discover user calendars if we have a calendar path in config
        if let Some(calendar_path) = &self.config.calendar_path {
            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
        let user_calendar_path = format!("/calendars/{}/", self.config.username);
        let user_dav_calendar_path = format!("/dav.php/calendars/{}/", self.config.username);
        let discovery_paths = vec![
            "/calendars/",
            user_calendar_path.as_str(),
            user_dav_calendar_path.as_str(),
            "/dav.php/calendars/",
        ];
        let mut all_calendars = Vec::new();
        for path in discovery_paths {
            println!("Trying discovery path: {}", path);
            if let Ok(calendars) = self.discover_calendars_at_path(&path).await {
                println!("Found {} calendar(s) at {}", calendars.len(), path);
                all_calendars.extend(calendars);
            }
        }
        // Remove duplicates
        all_calendars.sort();
        all_calendars.dedup();
        Ok(all_calendars)
    }
    /// Discover calendars at a specific path
    async fn discover_calendars_at_path(&self, path: &str) -> Result<Vec<String>, CalDAVError> {
        let propfind_body = r#"<?xml version="1.0" encoding="utf-8" ?>
 <d:propfind xmlns:d="DAV:" xmlns:c="urn:ietf:params:xml:ns:caldav">
    <d:prop>
        <d:resourcetype />
        <d:displayname />
        <c:supported-calendar-component-set />
    </d:prop>
 </d:propfind>"#;
        let url = format!("{}{}", self.config.server_url.trim_end_matches('/'), path);
        let response = self.http_client
            .request(reqwest::Method::from_bytes(b"PROPFIND").unwrap(), &url)
            .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")
            .body(propfind_body)
            .send()
            .await
            .map_err(CalDAVError::RequestError)?;
        if response.status().as_u16() != 207 {
            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];
                // Look for actual calendar collections (not just containers)
                if response_content.contains("<c:supported-calendar-component-set") || 
                   (response_content.contains("<d:collection/>") && 
                    response_content.contains("calendar")) {
                    if let Some(href) = self.extract_xml_content(response_content, "href") {
                        // Only include actual calendar paths, not container directories
                        if href.ends_with('/') && href.contains("calendar") && !href.ends_with("/calendars/") {
                            calendar_paths.push(href);
                        }
                    }
                }
            }
        }
        Ok(calendar_paths)
    }
    /// Parse iCal datetime format
    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
        ];
        for format in &formats {
            if let Ok(dt) = chrono::NaiveDateTime::parse_from_str(&cleaned, format) {
                return Ok(Utc.from_utc_datetime(&dt));
            }
            if let Ok(date) = chrono::NaiveDate::parse_from_str(&cleaned, format) {
                return Ok(Utc.from_utc_datetime(&date.and_hms_opt(0, 0, 0).unwrap()));
            }
        }
        Err(CalDAVError::ParseError(format!("Unable to parse datetime: {}", datetime_str)))
    }
 }
 /// Helper struct for extracting calendar data from XML responses
 #[derive(Debug)]
 struct CalendarDataSection {
    pub href: Option<String>,
    pub etag: Option<String>,
    pub data: String,
 }
 /// CalDAV-specific error types
 #[derive(Debug, thiserror::Error)]
 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),
    #[error("Configuration error: {0}")]
    ConfigError(String),
 }
 #[cfg(test)]
 mod tests {
    use super::*;
    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 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);
                            println!("Summary: {:?}", event.summary);
                            println!("Start: {}", event.start);
                            println!("End: {:?}", event.end);
                            println!("All Day: {}", event.all_day);
                            println!("Status: {:?}", event.status);
                            println!("Location: {:?}", event.location);
                            println!("Description: {:?}", event.description);
                            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.start > DateTime::from_timestamp(0, 0).unwrap(), "Event should have valid start time");
                        }
                        println!("\n✓ Calendar event fetching test passed!");
                    }
                    Err(e) => {
                        println!("Error fetching events from {}: {:?}", calendar_path, e);
                        println!("This might be normal if the calendar is empty");
                    }
                }
            }
            Err(e) => {
                println!("Error discovering calendars: {:?}", e);
                println!("This might be normal if no calendars are set up yet");
            }
        }
    }
    /// Test parsing a sample iCal event
    #[test]
    fn test_parse_ical_event() {
        let sample_ical = r#"BEGIN:VCALENDAR
 VERSION:2.0
 PRODID:-//Test//Test//EN
 BEGIN:VEVENT
 UID:test-event-123@example.com
 DTSTART:20231225T120000Z
 DTEND:20231225T130000Z
 SUMMARY:Test Event
 DESCRIPTION:This is a test event
 LOCATION:Test Location
 STATUS:CONFIRMED
 CLASS:PUBLIC
 PRIORITY:5
 CREATED:20231220T100000Z
 LAST-MODIFIED:20231221T150000Z
 CATEGORIES:work,important
 END:VEVENT
 END:VCALENDAR"#;
        let config = CalDAVConfig {
            server_url: "https://example.com".to_string(),
            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)
            .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()));
        assert_eq!(event.description, Some("This is a test event".to_string()));
        assert_eq!(event.location, Some("Test Location".to_string()));
        assert_eq!(event.status, EventStatus::Confirmed);
        assert_eq!(event.class, EventClass::Public);
        assert_eq!(event.priority, Some(5));
        assert_eq!(event.categories, vec!["work", "important"]);
        assert!(!event.all_day);
        println!("✓ iCal parsing test passed!");
    }
    /// Test datetime parsing
    #[test]
    fn test_datetime_parsing() {
        let config = CalDAVConfig {
            server_url: "https://example.com".to_string(),
            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)
            .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)
            .expect("Should parse date-only");
        println!("Parsed date-only: {}", dt2);
        // Test local format
        let dt3 = client.parse_datetime("20231225T120000", None)
            .expect("Should parse local datetime");
        println!("Parsed local datetime: {}", dt3);
        println!("✓ Datetime parsing test passed!");
    }
    /// Test event status parsing
    #[test]
    fn test_event_enums() {
        // Test status parsing
        assert_eq!(EventStatus::default(), EventStatus::Confirmed);
        // Test class parsing  
        assert_eq!(EventClass::default(), EventClass::Public);
        println!("✓ Event enum tests passed!");
    }
 }
--- a/src/components/login.rs
+++ b/src/components/login.rs
@@ -0,0 +1,152 @@
 use yew::prelude::*;
 use web_sys::HtmlInputElement;
 use gloo_storage::{LocalStorage, Storage};
 #[derive(Properties, PartialEq)]
 pub struct LoginProps {
    pub on_login: Callback<String>, // Callback with JWT token
 }
 #[function_component]
 pub fn Login(props: &LoginProps) -> Html {
    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 username_ref = use_node_ref();
    let password_ref = use_node_ref();
    let on_username_change = {
        let username = username.clone();
        Callback::from(move |e: Event| {
            let target = e.target_unchecked_into::<HtmlInputElement>();
            username.set(target.value());
        })
    };
    let on_password_change = {
        let password = password.clone();
        Callback::from(move |e: Event| {
            let target = e.target_unchecked_into::<HtmlInputElement>();
            password.set(target.value());
        })
    };
    let on_submit = {
        let username = username.clone();
        let password = password.clone();
        let error_message = error_message.clone();
        let is_loading = is_loading.clone();
        let on_login = props.on_login.clone();
        Callback::from(move |e: SubmitEvent| {
            e.prevent_default();
            let username = (*username).clone();
            let password = (*password).clone();
            let error_message = error_message.clone();
            let is_loading = is_loading.clone();
            let on_login = on_login.clone();
            // Basic client-side validation
            if username.trim().is_empty() || password.is_empty() {
                error_message.set(Some("Please fill in all fields".to_string()));
                return;
            }
            is_loading.set(true);
            error_message.set(None);
            wasm_bindgen_futures::spawn_local(async move {
                match perform_login(username, password).await {
                    Ok(token) => {
                        // Store token 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;
                        }
                        is_loading.set(false);
                        on_login.emit(token);
                    }
                    Err(err) => {
                        error_message.set(Some(err));
                        is_loading.set(false);
                    }
                }
            });
        })
    };
    html! {
        <div class="login-container">
            <div class="login-form">
                <h2>{"Sign In"}</h2>
                <form onsubmit={on_submit}>
                    <div class="form-group">
                        <label for="username">{"Username"}</label>
                        <input
                            ref={username_ref}
                            type="text"
                            id="username"
                            placeholder="Enter your username"
                            value={(*username).clone()}
                            onchange={on_username_change}
                            disabled={*is_loading}
                        />
                    </div>
                    <div class="form-group">
                        <label for="password">{"Password"}</label>
                        <input
                            ref={password_ref}
                            type="password"
                            id="password"
                            placeholder="Enter your password"
                            value={(*password).clone()}
                            onchange={on_password_change}
                            disabled={*is_loading}
                        />
                    </div>
                    {
                        if let Some(error) = (*error_message).clone() {
                            html! { <div class="error-message">{error}</div> }
                        } else {
                            html! {}
                        }
                    }
                    <button type="submit" disabled={*is_loading} class="login-button">
                        {
                            if *is_loading {
                                "Signing in..."
                            } else {
                                "Sign In"
                            }
                        }
                    </button>
                </form>
                <div class="auth-links">
                    <p>{"Don't have an account? "}<a href="/register">{"Sign up here"}</a></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};
    let auth_service = AuthService::new();
    let request = LoginRequest { username, password };
    match auth_service.login(request).await {
        Ok(response) => Ok(response.token),
        Err(err) => Err(err),
    }
 }
--- a/src/components/mod.rs
+++ b/src/components/mod.rs
@@ -0,0 +1,5 @@
 pub mod login;
 pub mod register;
 pub use login::Login;
 pub use register::Register;
--- a/src/components/register.rs
+++ b/src/components/register.rs
@@ -0,0 +1,235 @@
 use yew::prelude::*;
 use web_sys::HtmlInputElement;
 use gloo_storage::{LocalStorage, Storage};
 #[derive(Properties, PartialEq)]
 pub struct RegisterProps {
    pub on_register: Callback<String>, // Callback with JWT token
 }
 #[function_component]
 pub fn Register(props: &RegisterProps) -> Html {
    let username = use_state(String::new);
    let email = use_state(String::new);
    let password = use_state(String::new);
    let confirm_password = use_state(String::new);
    let error_message = use_state(|| Option::<String>::None);
    let is_loading = use_state(|| false);
    let username_ref = use_node_ref();
    let email_ref = use_node_ref();
    let password_ref = use_node_ref();
    let confirm_password_ref = use_node_ref();
    let on_username_change = {
        let username = username.clone();
        Callback::from(move |e: Event| {
            let target = e.target_unchecked_into::<HtmlInputElement>();
            username.set(target.value());
        })
    };
    let on_email_change = {
        let email = email.clone();
        Callback::from(move |e: Event| {
            let target = e.target_unchecked_into::<HtmlInputElement>();
            email.set(target.value());
        })
    };
    let on_password_change = {
        let password = password.clone();
        Callback::from(move |e: Event| {
            let target = e.target_unchecked_into::<HtmlInputElement>();
            password.set(target.value());
        })
    };
    let on_confirm_password_change = {
        let confirm_password = confirm_password.clone();
        Callback::from(move |e: Event| {
            let target = e.target_unchecked_into::<HtmlInputElement>();
            confirm_password.set(target.value());
        })
    };
    let on_submit = {
        let username = username.clone();
        let email = email.clone();
        let password = password.clone();
        let confirm_password = confirm_password.clone();
        let error_message = error_message.clone();
        let is_loading = is_loading.clone();
        let on_register = props.on_register.clone();
        Callback::from(move |e: SubmitEvent| {
            e.prevent_default();
            let username = (*username).clone();
            let email = (*email).clone();
            let password = (*password).clone();
            let confirm_password = (*confirm_password).clone();
            let error_message = error_message.clone();
            let is_loading = is_loading.clone();
            let on_register = on_register.clone();
            // Client-side validation
            if let Err(validation_error) = validate_registration(&username, &email, &password, &confirm_password) {
                error_message.set(Some(validation_error));
                return;
            }
            is_loading.set(true);
            error_message.set(None);
            wasm_bindgen_futures::spawn_local(async move {
                match perform_registration(username, email, password).await {
                    Ok(token) => {
                        // Store token 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;
                        }
                        is_loading.set(false);
                        on_register.emit(token);
                    }
                    Err(err) => {
                        error_message.set(Some(err));
                        is_loading.set(false);
                    }
                }
            });
        })
    };
    html! {
        <div class="register-container">
            <div class="register-form">
                <h2>{"Create Account"}</h2>
                <form onsubmit={on_submit}>
                    <div class="form-group">
                        <label for="username">{"Username"}</label>
                        <input
                            ref={username_ref}
                            type="text"
                            id="username"
                            placeholder="Choose a username"
                            value={(*username).clone()}
                            onchange={on_username_change}
                            disabled={*is_loading}
                        />
                    </div>
                    <div class="form-group">
                        <label for="email">{"Email"}</label>
                        <input
                            ref={email_ref}
                            type="email"
                            id="email"
                            placeholder="Enter your email"
                            value={(*email).clone()}
                            onchange={on_email_change}
                            disabled={*is_loading}
                        />
                    </div>
                    <div class="form-group">
                        <label for="password">{"Password"}</label>
                        <input
                            ref={password_ref}
                            type="password"
                            id="password"
                            placeholder="Choose a password"
                            value={(*password).clone()}
                            onchange={on_password_change}
                            disabled={*is_loading}
                        />
                    </div>
                    <div class="form-group">
                        <label for="confirm-password">{"Confirm Password"}</label>
                        <input
                            ref={confirm_password_ref}
                            type="password"
                            id="confirm-password"
                            placeholder="Confirm your password"
                            value={(*confirm_password).clone()}
                            onchange={on_confirm_password_change}
                            disabled={*is_loading}
                        />
                    </div>
                    {
                        if let Some(error) = (*error_message).clone() {
                            html! { <div class="error-message">{error}</div> }
                        } else {
                            html! {}
                        }
                    }
                    <button type="submit" disabled={*is_loading} class="register-button">
                        {
                            if *is_loading {
                                "Creating Account..."
                            } else {
                                "Create Account"
                            }
                        }
                    </button>
                </form>
                <div class="auth-links">
                    <p>{"Already have an account? "}<a href="/login">{"Sign in here"}</a></p>
                </div>
            </div>
        </div>
    }
 }
 /// Validate registration form data
 fn validate_registration(username: &str, email: &str, password: &str, confirm_password: &str) -> Result<(), String> {
    if username.trim().is_empty() {
        return Err("Username is required".to_string());
    }
    if username.len() < 3 {
        return Err("Username must be at least 3 characters long".to_string());
    }
    if email.trim().is_empty() {
        return Err("Email is required".to_string());
    }
    if !email.contains('@') {
        return Err("Please enter a valid email address".to_string());
    }
    if password.is_empty() {
        return Err("Password is required".to_string());
    }
    if password.len() < 6 {
        return Err("Password must be at least 6 characters long".to_string());
    }
    if password != confirm_password {
        return Err("Passwords do not match".to_string());
    }
    Ok(())
 }
 /// Perform registration using the auth service
 async fn perform_registration(username: String, email: String, password: String) -> Result<String, String> {
    use crate::auth::{AuthService, RegisterRequest};
    let auth_service = AuthService::new();
    let request = RegisterRequest { username, email, password };
    match auth_service.register(request).await {
        Ok(response) => Ok(response.token),
        Err(err) => Err(err),
    }
 }
--- a/src/main.rs
+++ b/src/main.rs
@@ -1,7 +1,9 @@
 use yew::prelude::*;
 mod app;
 mod config;
 mod calendar;
 mod auth;
 mod components;
 use app::App;