Compare commits
3 Commits
786f078e45
...
08c333dcba
| Author | SHA1 | Date | |
|---|---|---|---|
|
08c333dcba | ||
|
|
181e0c58c1 | ||
|
|
ad176dd423 |
19
Cargo.toml
19
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"] }
|
||||
250
index.html
250
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;
|
||||
background-color: #f5f5f5;
|
||||
padding: 0;
|
||||
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;
|
||||
background-color: white;
|
||||
width: 100%;
|
||||
}
|
||||
|
||||
/* 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>
|
||||
|
||||
124
src/app.rs
124
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>
|
||||
<h1>{ "Hello Yew!" }</h1>
|
||||
<p>{ "This is a basic Yew application template." }</p>
|
||||
<div>
|
||||
<div class="calendar-view">
|
||||
<h2>{"Welcome to your Calendar!"}</h2>
|
||||
<p>{"You are now authenticated and can access your calendar."}</p>
|
||||
|
||||
// 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>
|
||||
}
|
||||
}
|
||||
123
src/auth.rs
Normal file
123
src/auth.rs
Normal file
@@ -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())
|
||||
}
|
||||
}
|
||||
}
|
||||
639
src/calendar.rs
Normal file
639
src/calendar.rs
Normal file
@@ -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!");
|
||||
}
|
||||
}
|
||||
152
src/components/login.rs
Normal file
152
src/components/login.rs
Normal file
@@ -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),
|
||||
}
|
||||
}
|
||||
5
src/components/mod.rs
Normal file
5
src/components/mod.rs
Normal file
@@ -0,0 +1,5 @@
|
||||
pub mod login;
|
||||
pub mod register;
|
||||
|
||||
pub use login::Login;
|
||||
pub use register::Register;
|
||||
235
src/components/register.rs
Normal file
235
src/components/register.rs
Normal file
@@ -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),
|
||||
}
|
||||
}
|
||||
@@ -1,7 +1,9 @@
|
||||
use yew::prelude::*;
|
||||
|
||||
mod app;
|
||||
mod config;
|
||||
mod calendar;
|
||||
mod auth;
|
||||
mod components;
|
||||
|
||||
use app::App;
|
||||
|
||||
|
||||
Reference in New Issue
Block a user