d0aa6fda08
This commit resolves a significant bug where weekly recurring events with multiple selected days (BYDAY parameter) were only displaying the first 2 chronologically selected days instead of all selected days. ## Root Cause: The `next_weekday_occurrence` function was designed for single-occurrence processing, causing it to: - Find the first matching weekday in the current week - Return immediately, skipping subsequent selected days - Repeat this pattern across weeks, showing only the same first day repeatedly ## Solution: - **New Function**: `generate_weekly_byday_occurrences()` handles multiple days per week - **Week-by-Week Processing**: Generates events for ALL selected weekdays in each interval - **Comprehensive Logic**: Properly handles INTERVAL, COUNT, UNTIL, and EXDATE constraints - **Performance Optimized**: More efficient than single-occurrence iteration ## Technical Details: - Replaced linear occurrence processing with specialized weekly BYDAY handler - Added comprehensive debug logging for troubleshooting - Maintains full RFC 5545 RRULE compliance - Preserves existing functionality for non-BYDAY weekly events ## Expected Result: Users creating weekly recurring events with multiple days (e.g., Mon/Wed/Fri/Sat) will now see events appear on ALL selected days in each week interval, not just the first two. Example: "Every week on Mon, Wed, Fri, Sat" now correctly generates 4 events per week instead of just Monday events. 🤖 Generated with [Claude Code](https://claude.ai/code) Co-Authored-By: Claude <noreply@anthropic.com>
1280 lines
48 KiB
Rust
1280 lines
48 KiB
Rust
use chrono::{DateTime, Utc, NaiveDate, Datelike, Weekday, Duration, TimeZone};
|
|
use serde::{Deserialize, Serialize};
|
|
use wasm_bindgen::JsCast;
|
|
use wasm_bindgen_futures::JsFuture;
|
|
use web_sys::{Request, RequestInit, RequestMode, Response};
|
|
use std::collections::HashMap;
|
|
|
|
// Import RFC 5545 compliant VEvent from shared library
|
|
use calendar_models::VEvent;
|
|
|
|
// Create type alias for backward compatibility
|
|
pub type CalendarEvent = VEvent;
|
|
|
|
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
|
|
pub struct EventReminder {
|
|
pub minutes_before: i32,
|
|
pub action: ReminderAction,
|
|
pub description: Option<String>,
|
|
}
|
|
|
|
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
|
|
pub enum ReminderAction {
|
|
Display,
|
|
Email,
|
|
Audio,
|
|
}
|
|
|
|
impl Default for ReminderAction {
|
|
fn default() -> Self {
|
|
ReminderAction::Display
|
|
}
|
|
}
|
|
|
|
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
|
|
pub struct UserInfo {
|
|
pub username: String,
|
|
pub server_url: String,
|
|
pub calendars: Vec<CalendarInfo>,
|
|
}
|
|
|
|
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
|
|
pub struct CalendarInfo {
|
|
pub path: String,
|
|
pub display_name: String,
|
|
pub color: String,
|
|
}
|
|
|
|
// CalendarEvent, EventStatus, and EventClass are now imported from shared library
|
|
|
|
// ==================== V2 API MODELS ====================
|
|
|
|
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
|
|
pub struct AttendeeV2 {
|
|
pub email: String,
|
|
pub name: Option<String>,
|
|
pub role: Option<AttendeeRoleV2>,
|
|
pub status: Option<ParticipationStatusV2>,
|
|
pub rsvp: Option<bool>,
|
|
}
|
|
|
|
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
|
|
pub enum AttendeeRoleV2 {
|
|
Chair,
|
|
Required,
|
|
Optional,
|
|
NonParticipant,
|
|
}
|
|
|
|
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
|
|
pub enum ParticipationStatusV2 {
|
|
NeedsAction,
|
|
Accepted,
|
|
Declined,
|
|
Tentative,
|
|
Delegated,
|
|
}
|
|
|
|
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
|
|
pub struct AlarmV2 {
|
|
pub action: AlarmActionV2,
|
|
pub trigger_minutes: i32, // Minutes before event (negative = before)
|
|
pub description: Option<String>,
|
|
}
|
|
|
|
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
|
|
pub enum AlarmActionV2 {
|
|
Audio,
|
|
Display,
|
|
Email,
|
|
}
|
|
|
|
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
|
|
pub enum DeleteActionV2 {
|
|
DeleteThis,
|
|
DeleteFollowing,
|
|
DeleteSeries,
|
|
}
|
|
|
|
// V2 Request/Response Models
|
|
|
|
|
|
|
|
|
|
|
|
|
|
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
|
|
pub struct EventSummaryV2 {
|
|
pub uid: String,
|
|
pub summary: Option<String>,
|
|
pub dtstart: DateTime<Utc>,
|
|
pub dtend: Option<DateTime<Utc>>,
|
|
pub location: Option<String>,
|
|
pub all_day: bool,
|
|
pub href: Option<String>,
|
|
pub etag: Option<String>,
|
|
}
|
|
|
|
|
|
pub struct CalendarService {
|
|
base_url: String,
|
|
}
|
|
|
|
impl CalendarService {
|
|
pub fn new() -> Self {
|
|
let base_url = option_env!("BACKEND_API_URL")
|
|
.unwrap_or("http://localhost:3000/api")
|
|
.to_string();
|
|
|
|
Self { base_url }
|
|
}
|
|
|
|
/// Fetch user info including available calendars
|
|
pub async fn fetch_user_info(&self, token: &str, password: &str) -> Result<UserInfo, String> {
|
|
let window = web_sys::window().ok_or("No global window exists")?;
|
|
|
|
let opts = RequestInit::new();
|
|
opts.set_method("GET");
|
|
opts.set_mode(RequestMode::Cors);
|
|
|
|
let url = format!("{}/user/info", self.base_url);
|
|
let request = Request::new_with_str_and_init(&url, &opts)
|
|
.map_err(|e| format!("Request creation failed: {:?}", e))?;
|
|
|
|
request.headers().set("Authorization", &format!("Bearer {}", token))
|
|
.map_err(|e| format!("Authorization header setting failed: {:?}", e))?;
|
|
|
|
request.headers().set("X-CalDAV-Password", password)
|
|
.map_err(|e| format!("Password header setting failed: {:?}", e))?;
|
|
|
|
let resp_value = JsFuture::from(window.fetch_with_request(&request))
|
|
.await
|
|
.map_err(|e| format!("Network request failed: {:?}", e))?;
|
|
|
|
let resp: Response = resp_value.dyn_into()
|
|
.map_err(|e| format!("Response cast failed: {:?}", e))?;
|
|
|
|
let text = JsFuture::from(resp.text()
|
|
.map_err(|e| format!("Text extraction failed: {:?}", e))?)
|
|
.await
|
|
.map_err(|e| format!("Text promise failed: {:?}", e))?;
|
|
|
|
let text_string = text.as_string()
|
|
.ok_or("Response text is not a string")?;
|
|
|
|
if resp.ok() {
|
|
let user_info: UserInfo = serde_json::from_str(&text_string)
|
|
.map_err(|e| format!("JSON parsing failed: {}", e))?;
|
|
Ok(user_info)
|
|
} else {
|
|
Err(format!("Request failed with status {}: {}", resp.status(), text_string))
|
|
}
|
|
}
|
|
|
|
/// Fetch calendar events for a specific month
|
|
/// Fetch events for month as VEvent with RFC 5545 compliance
|
|
pub async fn fetch_events_for_month_vevent(
|
|
&self,
|
|
token: &str,
|
|
password: &str,
|
|
year: i32,
|
|
month: u32
|
|
) -> Result<Vec<VEvent>, String> {
|
|
// Since CalendarEvent is now a type alias for VEvent, just call the main method
|
|
self.fetch_events_for_month(token, password, year, month).await
|
|
}
|
|
|
|
pub async fn fetch_events_for_month(
|
|
&self,
|
|
token: &str,
|
|
password: &str,
|
|
year: i32,
|
|
month: u32
|
|
) -> Result<Vec<CalendarEvent>, String> {
|
|
let window = web_sys::window().ok_or("No global window exists")?;
|
|
|
|
let opts = RequestInit::new();
|
|
opts.set_method("GET");
|
|
opts.set_mode(RequestMode::Cors);
|
|
|
|
let url = format!("{}/calendar/events?year={}&month={}", self.base_url, year, month);
|
|
let request = Request::new_with_str_and_init(&url, &opts)
|
|
.map_err(|e| format!("Request creation failed: {:?}", e))?;
|
|
|
|
request.headers().set("Authorization", &format!("Bearer {}", token))
|
|
.map_err(|e| format!("Authorization header setting failed: {:?}", e))?;
|
|
|
|
request.headers().set("X-CalDAV-Password", password)
|
|
.map_err(|e| format!("Password header setting failed: {:?}", e))?;
|
|
|
|
let resp_value = JsFuture::from(window.fetch_with_request(&request))
|
|
.await
|
|
.map_err(|e| format!("Network request failed: {:?}", e))?;
|
|
|
|
let resp: Response = resp_value.dyn_into()
|
|
.map_err(|e| format!("Response cast failed: {:?}", e))?;
|
|
|
|
let text = JsFuture::from(resp.text()
|
|
.map_err(|e| format!("Text extraction failed: {:?}", e))?)
|
|
.await
|
|
.map_err(|e| format!("Text promise failed: {:?}", e))?;
|
|
|
|
let text_string = text.as_string()
|
|
.ok_or("Response text is not a string")?;
|
|
|
|
if resp.ok() {
|
|
let events: Vec<CalendarEvent> = serde_json::from_str(&text_string)
|
|
.map_err(|e| format!("JSON parsing failed: {}", e))?;
|
|
Ok(events)
|
|
} else {
|
|
Err(format!("Request failed with status {}: {}", resp.status(), text_string))
|
|
}
|
|
}
|
|
|
|
/// Convert events to a HashMap grouped by date for calendar display
|
|
/// Internally uses VEvent for RFC 5545 compliance while maintaining CalendarEvent API
|
|
/// Group VEvents by date with RFC 5545 compliance
|
|
pub fn group_events_by_date(events: Vec<VEvent>) -> HashMap<NaiveDate, Vec<VEvent>> {
|
|
let mut grouped = HashMap::new();
|
|
|
|
// Expand recurring events using VEvent (better RFC 5545 compliance)
|
|
let expanded_vevents = Self::expand_recurring_events(events);
|
|
|
|
// Group by date
|
|
for vevent in expanded_vevents {
|
|
let date = vevent.get_date();
|
|
grouped.entry(date).or_insert_with(Vec::new).push(vevent);
|
|
}
|
|
|
|
grouped
|
|
}
|
|
|
|
|
|
/// Expand recurring events using VEvent (RFC 5545 compliant)
|
|
pub fn expand_recurring_events(events: Vec<VEvent>) -> Vec<VEvent> {
|
|
let mut expanded_events = Vec::new();
|
|
let today = chrono::Utc::now().date_naive();
|
|
let start_range = today - Duration::days(30); // Show past 30 days
|
|
let end_range = today + Duration::days(365); // Show next 365 days
|
|
|
|
for event in events {
|
|
if let Some(ref rrule) = event.rrule {
|
|
web_sys::console::log_1(&format!("📅 Processing recurring VEvent '{}' with RRULE: {}",
|
|
event.summary.as_deref().unwrap_or("Untitled"),
|
|
rrule
|
|
).into());
|
|
|
|
// Log if event has exception dates
|
|
if !event.exdate.is_empty() {
|
|
web_sys::console::log_1(&format!("📅 VEvent '{}' has {} exception dates: {:?}",
|
|
event.summary.as_deref().unwrap_or("Untitled"),
|
|
event.exdate.len(),
|
|
event.exdate
|
|
).into());
|
|
}
|
|
|
|
// Generate occurrences for recurring events using VEvent
|
|
let occurrences = Self::generate_occurrences(&event, rrule, start_range, end_range);
|
|
web_sys::console::log_1(&format!("📅 Generated {} occurrences for VEvent '{}'",
|
|
occurrences.len(),
|
|
event.summary.as_deref().unwrap_or("Untitled")
|
|
).into());
|
|
expanded_events.extend(occurrences);
|
|
} else {
|
|
// Non-recurring event - add as-is
|
|
expanded_events.push(event);
|
|
}
|
|
}
|
|
|
|
expanded_events
|
|
}
|
|
|
|
|
|
/// Generate occurrence dates for a recurring VEvent based on RRULE (RFC 5545 compliant)
|
|
fn generate_occurrences(
|
|
base_event: &VEvent,
|
|
rrule: &str,
|
|
start_range: NaiveDate,
|
|
end_range: NaiveDate,
|
|
) -> Vec<VEvent> {
|
|
let mut occurrences = Vec::new();
|
|
|
|
// Parse RRULE components
|
|
let rrule_upper = rrule.to_uppercase();
|
|
web_sys::console::log_1(&format!("🔄 Parsing RRULE: {}", rrule_upper).into());
|
|
|
|
let components: HashMap<String, String> = rrule_upper
|
|
.split(';')
|
|
.filter_map(|part| {
|
|
let mut split = part.split('=');
|
|
if let (Some(key), Some(value)) = (split.next(), split.next()) {
|
|
Some((key.to_string(), value.to_string()))
|
|
} else {
|
|
None
|
|
}
|
|
})
|
|
.collect();
|
|
|
|
// Get frequency
|
|
let freq = components.get("FREQ").map(|s| s.as_str()).unwrap_or("DAILY");
|
|
|
|
// Get interval (default 1)
|
|
let interval: i32 = components.get("INTERVAL")
|
|
.and_then(|s| s.parse().ok())
|
|
.unwrap_or(1);
|
|
|
|
// Get count limit (default 100 to prevent infinite loops)
|
|
let count: usize = components.get("COUNT")
|
|
.and_then(|s| s.parse().ok())
|
|
.unwrap_or(100)
|
|
.min(365); // Cap at 365 occurrences for performance
|
|
|
|
// Get UNTIL date if specified
|
|
let until_date = components.get("UNTIL")
|
|
.and_then(|until_str| {
|
|
// Parse UNTIL date in YYYYMMDDTHHMMSSZ format
|
|
if let Ok(dt) = chrono::NaiveDateTime::parse_from_str(until_str.trim_end_matches('Z'), "%Y%m%dT%H%M%S") {
|
|
Some(chrono::Utc.from_utc_datetime(&dt))
|
|
} else if let Ok(dt) = chrono::DateTime::parse_from_str(until_str, "%Y%m%dT%H%M%SZ") {
|
|
Some(dt.with_timezone(&chrono::Utc))
|
|
} else if let Ok(date) = chrono::NaiveDate::parse_from_str(until_str, "%Y%m%d") {
|
|
// Handle date-only UNTIL
|
|
Some(chrono::Utc.from_utc_datetime(&date.and_hms_opt(23, 59, 59).unwrap()))
|
|
} else {
|
|
web_sys::console::log_1(&format!("⚠️ Failed to parse UNTIL date: {}", until_str).into());
|
|
None
|
|
}
|
|
});
|
|
|
|
if let Some(until) = until_date {
|
|
web_sys::console::log_1(&format!("📅 RRULE has UNTIL: {}", until).into());
|
|
}
|
|
|
|
let start_date = base_event.dtstart.date_naive();
|
|
let mut current_date = start_date;
|
|
let mut occurrence_count = 0;
|
|
|
|
// Generate occurrences based on frequency
|
|
while current_date <= end_range && occurrence_count < count {
|
|
// Check UNTIL constraint - stop if current occurrence is after UNTIL date
|
|
if let Some(until) = until_date {
|
|
let current_datetime = base_event.dtstart + Duration::days(current_date.signed_duration_since(start_date).num_days());
|
|
if current_datetime > until {
|
|
web_sys::console::log_1(&format!("🛑 Stopping at {} due to UNTIL {}", current_datetime, until).into());
|
|
break;
|
|
}
|
|
}
|
|
|
|
if current_date >= start_range {
|
|
// Calculate the occurrence datetime
|
|
let days_diff = current_date.signed_duration_since(start_date).num_days();
|
|
let occurrence_datetime = base_event.dtstart + Duration::days(days_diff);
|
|
|
|
// Check if this occurrence is in the exception dates (EXDATE)
|
|
let is_exception = base_event.exdate.iter().any(|exception_date| {
|
|
// Compare dates ignoring sub-second precision
|
|
let exception_naive = exception_date.naive_utc();
|
|
let occurrence_naive = occurrence_datetime.naive_utc();
|
|
|
|
// Check if dates match (within a minute to handle minor time differences)
|
|
let diff = occurrence_naive - exception_naive;
|
|
let matches = diff.num_seconds().abs() < 60;
|
|
|
|
if matches {
|
|
web_sys::console::log_1(&format!("🚫 Excluding occurrence {} due to EXDATE {}", occurrence_naive, exception_naive).into());
|
|
}
|
|
|
|
matches
|
|
});
|
|
|
|
if !is_exception {
|
|
// Create occurrence event with updated DTSTAMP
|
|
let mut occurrence_event = base_event.clone();
|
|
occurrence_event.dtstart = occurrence_datetime;
|
|
occurrence_event.dtstamp = chrono::Utc::now(); // Update DTSTAMP for each occurrence
|
|
|
|
if let Some(end) = base_event.dtend {
|
|
occurrence_event.dtend = Some(end + Duration::days(days_diff));
|
|
}
|
|
|
|
occurrences.push(occurrence_event);
|
|
}
|
|
}
|
|
|
|
// Calculate next occurrence date
|
|
match freq {
|
|
"DAILY" => {
|
|
current_date = current_date + Duration::days(interval as i64);
|
|
}
|
|
"WEEKLY" => {
|
|
if let Some(byday) = components.get("BYDAY") {
|
|
// For BYDAY weekly events, we need to handle multiple days per week
|
|
// Break out of the single-occurrence loop and use specialized logic
|
|
return Self::generate_weekly_byday_occurrences(
|
|
base_event,
|
|
byday,
|
|
interval,
|
|
start_range,
|
|
end_range,
|
|
until_date,
|
|
count
|
|
);
|
|
} else {
|
|
current_date = current_date + Duration::weeks(interval as i64);
|
|
}
|
|
}
|
|
"MONTHLY" => {
|
|
// Simple monthly increment (same day of month)
|
|
if let Some(next_month) = Self::add_months(current_date, interval) {
|
|
current_date = next_month;
|
|
} else {
|
|
break; // Invalid date
|
|
}
|
|
}
|
|
"YEARLY" => {
|
|
if let Some(next_year) = Self::add_years(current_date, interval) {
|
|
current_date = next_year;
|
|
} else {
|
|
break; // Invalid date
|
|
}
|
|
}
|
|
_ => break, // Unsupported frequency
|
|
}
|
|
|
|
occurrence_count += 1;
|
|
}
|
|
|
|
occurrences
|
|
}
|
|
|
|
/// Generate occurrences for WEEKLY frequency with BYDAY (handles multiple days per week)
|
|
fn generate_weekly_byday_occurrences(
|
|
base_event: &VEvent,
|
|
byday: &str,
|
|
interval: i32,
|
|
start_range: NaiveDate,
|
|
end_range: NaiveDate,
|
|
until_date: Option<chrono::DateTime<chrono::Utc>>,
|
|
count: usize,
|
|
) -> Vec<VEvent> {
|
|
let mut occurrences = Vec::new();
|
|
let weekdays = Self::parse_byday(byday);
|
|
|
|
if weekdays.is_empty() {
|
|
return occurrences;
|
|
}
|
|
|
|
web_sys::console::log_1(&format!("🗓️ Generating WEEKLY BYDAY occurrences for days: {:?}", weekdays).into());
|
|
|
|
let start_date = base_event.dtstart.date_naive();
|
|
let mut current_week_start = start_date - Duration::days(start_date.weekday().num_days_from_monday() as i64);
|
|
let mut total_occurrences = 0;
|
|
|
|
// Generate occurrences week by week
|
|
while current_week_start <= end_range && total_occurrences < count {
|
|
// Generate occurrences for all matching weekdays in this week
|
|
for &weekday in &weekdays {
|
|
let occurrence_date = current_week_start + Duration::days(weekday.num_days_from_monday() as i64);
|
|
|
|
// Skip if occurrence is before start_range or after end_range
|
|
if occurrence_date < start_range || occurrence_date > end_range {
|
|
continue;
|
|
}
|
|
|
|
// Skip if we've reached the count limit
|
|
if total_occurrences >= count {
|
|
break;
|
|
}
|
|
|
|
// Check UNTIL constraint
|
|
if let Some(until) = until_date {
|
|
let days_diff = occurrence_date.signed_duration_since(start_date).num_days();
|
|
let occurrence_datetime = base_event.dtstart + Duration::days(days_diff);
|
|
if occurrence_datetime > until {
|
|
web_sys::console::log_1(&format!("🛑 Stopping at {} due to UNTIL {}", occurrence_datetime, until).into());
|
|
return occurrences;
|
|
}
|
|
}
|
|
|
|
// Skip if this occurrence is before the original event date
|
|
if occurrence_date < start_date {
|
|
continue;
|
|
}
|
|
|
|
// Calculate the occurrence datetime
|
|
let days_diff = occurrence_date.signed_duration_since(start_date).num_days();
|
|
let occurrence_datetime = base_event.dtstart + Duration::days(days_diff);
|
|
|
|
// Check if this occurrence is in the exception dates (EXDATE)
|
|
let is_exception = base_event.exdate.iter().any(|exception_date| {
|
|
let exception_naive = exception_date.naive_utc();
|
|
let occurrence_naive = occurrence_datetime.naive_utc();
|
|
let diff = occurrence_naive - exception_naive;
|
|
let matches = diff.num_seconds().abs() < 60;
|
|
|
|
if matches {
|
|
web_sys::console::log_1(&format!("🚫 Excluding occurrence {} due to EXDATE {}", occurrence_naive, exception_naive).into());
|
|
}
|
|
|
|
matches
|
|
});
|
|
|
|
if !is_exception {
|
|
// Create occurrence event
|
|
let mut occurrence_event = base_event.clone();
|
|
occurrence_event.dtstart = occurrence_datetime;
|
|
occurrence_event.dtstamp = chrono::Utc::now();
|
|
|
|
if let Some(end) = base_event.dtend {
|
|
occurrence_event.dtend = Some(end + Duration::days(days_diff));
|
|
}
|
|
|
|
web_sys::console::log_1(&format!("📅 Generated weekly occurrence on {}", occurrence_date).into());
|
|
occurrences.push(occurrence_event);
|
|
total_occurrences += 1;
|
|
}
|
|
}
|
|
|
|
// Move to next week interval
|
|
current_week_start = current_week_start + Duration::weeks(interval as i64);
|
|
}
|
|
|
|
web_sys::console::log_1(&format!("✅ Generated {} total weekly BYDAY occurrences", occurrences.len()).into());
|
|
occurrences
|
|
}
|
|
|
|
|
|
/// Calculate next weekday occurrence for WEEKLY frequency with BYDAY
|
|
fn next_weekday_occurrence(current_date: NaiveDate, byday: &str, interval: i32) -> NaiveDate {
|
|
let weekdays = Self::parse_byday(byday);
|
|
if weekdays.is_empty() {
|
|
return current_date + Duration::weeks(interval as i64);
|
|
}
|
|
|
|
let current_weekday = current_date.weekday();
|
|
|
|
// Find next occurrence within current week
|
|
let mut next_occurrences = Vec::new();
|
|
for &target_weekday in &weekdays {
|
|
let days_until = Self::days_until_weekday(current_weekday, target_weekday);
|
|
if days_until > 0 {
|
|
next_occurrences.push((days_until, target_weekday));
|
|
}
|
|
}
|
|
|
|
// Sort by days_until and return the closest one
|
|
if !next_occurrences.is_empty() {
|
|
next_occurrences.sort_by_key(|(days, _)| *days);
|
|
return current_date + Duration::days(next_occurrences[0].0 as i64);
|
|
}
|
|
|
|
// No more occurrences this week, move to next interval
|
|
let next_week_start = current_date + Duration::weeks(interval as i64) - Duration::days(current_weekday.num_days_from_monday() as i64);
|
|
next_week_start + Duration::days(weekdays[0].num_days_from_monday() as i64)
|
|
}
|
|
|
|
/// Parse BYDAY parameter (e.g., "MO,WE,FR" -> [Monday, Wednesday, Friday])
|
|
fn parse_byday(byday: &str) -> Vec<Weekday> {
|
|
byday
|
|
.split(',')
|
|
.filter_map(|day| match day {
|
|
"MO" => Some(Weekday::Mon),
|
|
"TU" => Some(Weekday::Tue),
|
|
"WE" => Some(Weekday::Wed),
|
|
"TH" => Some(Weekday::Thu),
|
|
"FR" => Some(Weekday::Fri),
|
|
"SA" => Some(Weekday::Sat),
|
|
"SU" => Some(Weekday::Sun),
|
|
_ => None,
|
|
})
|
|
.collect()
|
|
}
|
|
|
|
/// Calculate days until target weekday
|
|
fn days_until_weekday(from: Weekday, to: Weekday) -> i32 {
|
|
let from_num = from.num_days_from_monday();
|
|
let to_num = to.num_days_from_monday();
|
|
|
|
if to_num > from_num {
|
|
(to_num - from_num) as i32
|
|
} else if to_num < from_num {
|
|
(7 + to_num - from_num) as i32
|
|
} else {
|
|
0 // Same day
|
|
}
|
|
}
|
|
|
|
/// Add months to a date (handling month boundary issues)
|
|
fn add_months(date: NaiveDate, months: i32) -> Option<NaiveDate> {
|
|
let mut year = date.year();
|
|
let mut month = date.month() as i32 + months;
|
|
|
|
while month > 12 {
|
|
year += 1;
|
|
month -= 12;
|
|
}
|
|
while month < 1 {
|
|
year -= 1;
|
|
month += 12;
|
|
}
|
|
|
|
// Handle day overflow (e.g., Jan 31 -> Feb 28)
|
|
let day = date.day().min(Self::days_in_month(year, month as u32));
|
|
|
|
NaiveDate::from_ymd_opt(year, month as u32, day)
|
|
}
|
|
|
|
/// Add years to a date
|
|
fn add_years(date: NaiveDate, years: i32) -> Option<NaiveDate> {
|
|
NaiveDate::from_ymd_opt(date.year() + years, date.month(), date.day())
|
|
}
|
|
|
|
/// Get number of days in a month
|
|
fn days_in_month(year: i32, month: u32) -> u32 {
|
|
match month {
|
|
1 | 3 | 5 | 7 | 8 | 10 | 12 => 31,
|
|
4 | 6 | 9 | 11 => 30,
|
|
2 => if Self::is_leap_year(year) { 29 } else { 28 },
|
|
_ => 30,
|
|
}
|
|
}
|
|
|
|
/// Check if year is leap year
|
|
fn is_leap_year(year: i32) -> bool {
|
|
(year % 4 == 0 && year % 100 != 0) || (year % 400 == 0)
|
|
}
|
|
|
|
/// Create a new calendar on the CalDAV server
|
|
pub async fn create_calendar(
|
|
&self,
|
|
token: &str,
|
|
password: &str,
|
|
name: String,
|
|
description: Option<String>,
|
|
color: Option<String>
|
|
) -> Result<(), String> {
|
|
let window = web_sys::window().ok_or("No global window exists")?;
|
|
|
|
let opts = RequestInit::new();
|
|
opts.set_method("POST");
|
|
opts.set_mode(RequestMode::Cors);
|
|
|
|
let body = serde_json::json!({
|
|
"name": name,
|
|
"description": description,
|
|
"color": color
|
|
});
|
|
|
|
let body_string = serde_json::to_string(&body)
|
|
.map_err(|e| format!("JSON serialization failed: {}", e))?;
|
|
|
|
opts.set_body(&body_string.into());
|
|
|
|
let url = format!("{}/calendar/create", self.base_url);
|
|
let request = Request::new_with_str_and_init(&url, &opts)
|
|
.map_err(|e| format!("Request creation failed: {:?}", e))?;
|
|
|
|
request.headers().set("Authorization", &format!("Bearer {}", token))
|
|
.map_err(|e| format!("Authorization header setting failed: {:?}", e))?;
|
|
|
|
request.headers().set("X-CalDAV-Password", password)
|
|
.map_err(|e| format!("Password header setting failed: {:?}", e))?;
|
|
|
|
request.headers().set("Content-Type", "application/json")
|
|
.map_err(|e| format!("Content-Type header setting failed: {:?}", e))?;
|
|
|
|
let resp_value = JsFuture::from(window.fetch_with_request(&request))
|
|
.await
|
|
.map_err(|e| format!("Network request failed: {:?}", e))?;
|
|
|
|
let resp: Response = resp_value.dyn_into()
|
|
.map_err(|e| format!("Response cast failed: {:?}", e))?;
|
|
|
|
let text = JsFuture::from(resp.text()
|
|
.map_err(|e| format!("Text extraction failed: {:?}", e))?)
|
|
.await
|
|
.map_err(|e| format!("Text promise failed: {:?}", e))?;
|
|
|
|
let text_string = text.as_string()
|
|
.ok_or("Response text is not a string")?;
|
|
|
|
if resp.ok() {
|
|
Ok(())
|
|
} else {
|
|
Err(format!("Request failed with status {}: {}", resp.status(), text_string))
|
|
}
|
|
}
|
|
|
|
/// Delete an event from the CalDAV server
|
|
pub async fn delete_event(
|
|
&self,
|
|
token: &str,
|
|
password: &str,
|
|
calendar_path: String,
|
|
event_href: String,
|
|
delete_action: String,
|
|
occurrence_date: Option<String>
|
|
) -> Result<String, String> {
|
|
// Forward to delete_event_with_uid with extracted UID
|
|
let event_uid = event_href.trim_end_matches(".ics").to_string();
|
|
self.delete_event_with_uid(
|
|
token, password, calendar_path, event_href, delete_action,
|
|
occurrence_date, event_uid, None // No recurrence info available
|
|
).await
|
|
}
|
|
|
|
/// Delete an event from the CalDAV server with UID and recurrence support
|
|
pub async fn delete_event_with_uid(
|
|
&self,
|
|
token: &str,
|
|
password: &str,
|
|
calendar_path: String,
|
|
event_href: String,
|
|
delete_action: String,
|
|
occurrence_date: Option<String>,
|
|
event_uid: String,
|
|
recurrence: Option<String>
|
|
) -> Result<String, String> {
|
|
let window = web_sys::window().ok_or("No global window exists")?;
|
|
|
|
let opts = RequestInit::new();
|
|
opts.set_method("POST");
|
|
opts.set_mode(RequestMode::Cors);
|
|
|
|
// Determine if this is a series event based on recurrence
|
|
let is_series = recurrence.as_ref()
|
|
.map(|r| !r.is_empty() && r.to_uppercase() != "NONE")
|
|
.unwrap_or(false);
|
|
|
|
let (body, url) = if is_series {
|
|
// Use series-specific endpoint and payload for recurring events
|
|
// Map delete_action to delete_scope for series endpoint
|
|
let delete_scope = match delete_action.as_str() {
|
|
"delete_this" => "this_only",
|
|
"delete_following" => "this_and_future",
|
|
"delete_series" => "all_in_series",
|
|
_ => "this_only" // Default to single occurrence
|
|
};
|
|
|
|
let body = serde_json::json!({
|
|
"series_uid": event_uid,
|
|
"calendar_path": calendar_path,
|
|
"event_href": event_href,
|
|
"delete_scope": delete_scope,
|
|
"occurrence_date": occurrence_date
|
|
});
|
|
let url = format!("{}/calendar/events/series/delete", self.base_url);
|
|
(body, url)
|
|
} else {
|
|
// Use regular endpoint for non-recurring events
|
|
let body = serde_json::json!({
|
|
"calendar_path": calendar_path,
|
|
"event_href": event_href,
|
|
"delete_action": delete_action,
|
|
"occurrence_date": occurrence_date
|
|
});
|
|
let url = format!("{}/calendar/events/delete", self.base_url);
|
|
(body, url)
|
|
};
|
|
|
|
let body_string = serde_json::to_string(&body)
|
|
.map_err(|e| format!("JSON serialization failed: {}", e))?;
|
|
opts.set_body(&body_string.into());
|
|
let request = Request::new_with_str_and_init(&url, &opts)
|
|
.map_err(|e| format!("Request creation failed: {:?}", e))?;
|
|
|
|
request.headers().set("Authorization", &format!("Bearer {}", token))
|
|
.map_err(|e| format!("Authorization header setting failed: {:?}", e))?;
|
|
|
|
request.headers().set("X-CalDAV-Password", password)
|
|
.map_err(|e| format!("Password header setting failed: {:?}", e))?;
|
|
|
|
request.headers().set("Content-Type", "application/json")
|
|
.map_err(|e| format!("Content-Type header setting failed: {:?}", e))?;
|
|
|
|
let resp_value = JsFuture::from(window.fetch_with_request(&request))
|
|
.await
|
|
.map_err(|e| format!("Network request failed: {:?}", e))?;
|
|
|
|
let resp: Response = resp_value.dyn_into()
|
|
.map_err(|e| format!("Response cast failed: {:?}", e))?;
|
|
|
|
let text = JsFuture::from(resp.text()
|
|
.map_err(|e| format!("Text extraction failed: {:?}", e))?)
|
|
.await
|
|
.map_err(|e| format!("Text promise failed: {:?}", e))?;
|
|
|
|
let text_string = text.as_string()
|
|
.ok_or("Response text is not a string")?;
|
|
|
|
if resp.ok() {
|
|
// Parse the response to get the message
|
|
let response: serde_json::Value = serde_json::from_str(&text_string)
|
|
.map_err(|e| format!("Failed to parse response JSON: {}", e))?;
|
|
let message = response["message"].as_str().unwrap_or("Event deleted successfully").to_string();
|
|
Ok(message)
|
|
} else {
|
|
Err(format!("Request failed with status {}: {}", resp.status(), text_string))
|
|
}
|
|
}
|
|
|
|
/// Create a new event on the CalDAV server
|
|
pub async fn create_event(
|
|
&self,
|
|
token: &str,
|
|
password: &str,
|
|
title: String,
|
|
description: String,
|
|
start_date: String,
|
|
start_time: String,
|
|
end_date: String,
|
|
end_time: String,
|
|
location: String,
|
|
all_day: bool,
|
|
status: String,
|
|
class: String,
|
|
priority: Option<u8>,
|
|
organizer: String,
|
|
attendees: String,
|
|
categories: String,
|
|
reminder: String,
|
|
recurrence: String,
|
|
recurrence_days: Vec<bool>,
|
|
calendar_path: Option<String>
|
|
) -> Result<(), String> {
|
|
let window = web_sys::window().ok_or("No global window exists")?;
|
|
|
|
let opts = RequestInit::new();
|
|
opts.set_method("POST");
|
|
opts.set_mode(RequestMode::Cors);
|
|
|
|
// Determine if this is a series event based on recurrence
|
|
let is_series = !recurrence.is_empty() && recurrence.to_uppercase() != "NONE";
|
|
|
|
let (body, url) = if is_series {
|
|
// Use series-specific endpoint and payload for recurring events
|
|
let body = serde_json::json!({
|
|
"title": title,
|
|
"description": description,
|
|
"start_date": start_date,
|
|
"start_time": start_time,
|
|
"end_date": end_date,
|
|
"end_time": end_time,
|
|
"location": location,
|
|
"all_day": all_day,
|
|
"status": status,
|
|
"class": class,
|
|
"priority": priority,
|
|
"organizer": organizer,
|
|
"attendees": attendees,
|
|
"categories": categories,
|
|
"reminder": reminder,
|
|
"recurrence": recurrence,
|
|
"recurrence_days": recurrence_days,
|
|
"recurrence_interval": 1_u32, // Default interval
|
|
"recurrence_end_date": None as Option<String>, // No end date by default
|
|
"recurrence_count": None as Option<u32>, // No count limit by default
|
|
"calendar_path": calendar_path
|
|
});
|
|
let url = format!("{}/calendar/events/series/create", self.base_url);
|
|
(body, url)
|
|
} else {
|
|
// Use regular endpoint for non-recurring events
|
|
let body = serde_json::json!({
|
|
"title": title,
|
|
"description": description,
|
|
"start_date": start_date,
|
|
"start_time": start_time,
|
|
"end_date": end_date,
|
|
"end_time": end_time,
|
|
"location": location,
|
|
"all_day": all_day,
|
|
"status": status,
|
|
"class": class,
|
|
"priority": priority,
|
|
"organizer": organizer,
|
|
"attendees": attendees,
|
|
"categories": categories,
|
|
"reminder": reminder,
|
|
"recurrence": recurrence,
|
|
"recurrence_days": recurrence_days,
|
|
"calendar_path": calendar_path
|
|
});
|
|
let url = format!("{}/calendar/events/create", self.base_url);
|
|
(body, url)
|
|
};
|
|
|
|
let body_string = serde_json::to_string(&body)
|
|
.map_err(|e| format!("JSON serialization failed: {}", e))?;
|
|
opts.set_body(&body_string.into());
|
|
let request = Request::new_with_str_and_init(&url, &opts)
|
|
.map_err(|e| format!("Request creation failed: {:?}", e))?;
|
|
|
|
request.headers().set("Authorization", &format!("Bearer {}", token))
|
|
.map_err(|e| format!("Authorization header setting failed: {:?}", e))?;
|
|
|
|
request.headers().set("X-CalDAV-Password", password)
|
|
.map_err(|e| format!("Password header setting failed: {:?}", e))?;
|
|
|
|
request.headers().set("Content-Type", "application/json")
|
|
.map_err(|e| format!("Content-Type header setting failed: {:?}", e))?;
|
|
|
|
let resp_value = JsFuture::from(window.fetch_with_request(&request))
|
|
.await
|
|
.map_err(|e| format!("Network request failed: {:?}", e))?;
|
|
|
|
let resp: Response = resp_value.dyn_into()
|
|
.map_err(|e| format!("Response cast failed: {:?}", e))?;
|
|
|
|
let text = JsFuture::from(resp.text()
|
|
.map_err(|e| format!("Text extraction failed: {:?}", e))?)
|
|
.await
|
|
.map_err(|e| format!("Text promise failed: {:?}", e))?;
|
|
|
|
let text_string = text.as_string()
|
|
.ok_or("Response text is not a string")?;
|
|
|
|
if resp.ok() {
|
|
Ok(())
|
|
} else {
|
|
Err(format!("Request failed with status {}: {}", resp.status(), text_string))
|
|
}
|
|
}
|
|
|
|
pub async fn update_event(
|
|
&self,
|
|
token: &str,
|
|
password: &str,
|
|
event_uid: String,
|
|
title: String,
|
|
description: String,
|
|
start_date: String,
|
|
start_time: String,
|
|
end_date: String,
|
|
end_time: String,
|
|
location: String,
|
|
all_day: bool,
|
|
status: String,
|
|
class: String,
|
|
priority: Option<u8>,
|
|
organizer: String,
|
|
attendees: String,
|
|
categories: String,
|
|
reminder: String,
|
|
recurrence: String,
|
|
recurrence_days: Vec<bool>,
|
|
calendar_path: Option<String>,
|
|
exception_dates: Vec<DateTime<Utc>>,
|
|
update_action: Option<String>,
|
|
until_date: Option<DateTime<Utc>>
|
|
) -> Result<(), String> {
|
|
// Forward to update_event_with_scope with default scope
|
|
self.update_event_with_scope(
|
|
token, password, event_uid, title, description,
|
|
start_date, start_time, end_date, end_time, location,
|
|
all_day, status, class, priority, organizer, attendees,
|
|
categories, reminder, recurrence, recurrence_days,
|
|
calendar_path, exception_dates, update_action, until_date
|
|
).await
|
|
}
|
|
|
|
pub async fn update_event_with_scope(
|
|
&self,
|
|
token: &str,
|
|
password: &str,
|
|
event_uid: String,
|
|
title: String,
|
|
description: String,
|
|
start_date: String,
|
|
start_time: String,
|
|
end_date: String,
|
|
end_time: String,
|
|
location: String,
|
|
all_day: bool,
|
|
status: String,
|
|
class: String,
|
|
priority: Option<u8>,
|
|
organizer: String,
|
|
attendees: String,
|
|
categories: String,
|
|
reminder: String,
|
|
recurrence: String,
|
|
recurrence_days: Vec<bool>,
|
|
calendar_path: Option<String>,
|
|
exception_dates: Vec<DateTime<Utc>>,
|
|
update_action: Option<String>,
|
|
until_date: Option<DateTime<Utc>>
|
|
) -> Result<(), String> {
|
|
let window = web_sys::window().ok_or("No global window exists")?;
|
|
|
|
let opts = RequestInit::new();
|
|
opts.set_method("POST");
|
|
opts.set_mode(RequestMode::Cors);
|
|
|
|
// Always use regular endpoint - recurring events should use update_series() instead
|
|
let body = serde_json::json!({
|
|
"uid": event_uid,
|
|
"title": title,
|
|
"description": description,
|
|
"start_date": start_date,
|
|
"start_time": start_time,
|
|
"end_date": end_date,
|
|
"end_time": end_time,
|
|
"location": location,
|
|
"all_day": all_day,
|
|
"status": status,
|
|
"class": class,
|
|
"priority": priority,
|
|
"organizer": organizer,
|
|
"attendees": attendees,
|
|
"categories": categories,
|
|
"reminder": reminder,
|
|
"recurrence": recurrence,
|
|
"recurrence_days": recurrence_days,
|
|
"calendar_path": calendar_path,
|
|
"update_action": update_action,
|
|
"occurrence_date": null,
|
|
"exception_dates": exception_dates.iter().map(|dt| dt.to_rfc3339()).collect::<Vec<String>>(),
|
|
"until_date": until_date.as_ref().map(|dt| dt.to_rfc3339())
|
|
});
|
|
let url = format!("{}/calendar/events/update", self.base_url);
|
|
|
|
let body_string = serde_json::to_string(&body)
|
|
.map_err(|e| format!("JSON serialization failed: {}", e))?;
|
|
opts.set_body(&body_string.into());
|
|
let request = Request::new_with_str_and_init(&url, &opts)
|
|
.map_err(|e| format!("Request creation failed: {:?}", e))?;
|
|
|
|
request.headers().set("Authorization", &format!("Bearer {}", token))
|
|
.map_err(|e| format!("Authorization header setting failed: {:?}", e))?;
|
|
|
|
request.headers().set("X-CalDAV-Password", password)
|
|
.map_err(|e| format!("Password header setting failed: {:?}", e))?;
|
|
|
|
request.headers().set("Content-Type", "application/json")
|
|
.map_err(|e| format!("Content-Type header setting failed: {:?}", e))?;
|
|
|
|
let resp_value = JsFuture::from(window.fetch_with_request(&request))
|
|
.await
|
|
.map_err(|e| format!("Network request failed: {:?}", e))?;
|
|
|
|
let resp: Response = resp_value.dyn_into()
|
|
.map_err(|e| format!("Response cast failed: {:?}", e))?;
|
|
|
|
let text = JsFuture::from(resp.text()
|
|
.map_err(|e| format!("Text extraction failed: {:?}", e))?)
|
|
.await
|
|
.map_err(|e| format!("Text promise failed: {:?}", e))?;
|
|
|
|
let text_string = text.as_string()
|
|
.ok_or("Response text is not a string")?;
|
|
|
|
if resp.ok() {
|
|
Ok(())
|
|
} else {
|
|
Err(format!("Request failed with status {}: {}", resp.status(), text_string))
|
|
}
|
|
}
|
|
|
|
/// Delete a calendar from the CalDAV server
|
|
pub async fn delete_calendar(
|
|
&self,
|
|
token: &str,
|
|
password: &str,
|
|
path: String
|
|
) -> Result<(), String> {
|
|
let window = web_sys::window().ok_or("No global window exists")?;
|
|
|
|
let opts = RequestInit::new();
|
|
opts.set_method("POST");
|
|
opts.set_mode(RequestMode::Cors);
|
|
|
|
let body = serde_json::json!({
|
|
"path": path
|
|
});
|
|
|
|
let body_string = serde_json::to_string(&body)
|
|
.map_err(|e| format!("JSON serialization failed: {}", e))?;
|
|
|
|
opts.set_body(&body_string.into());
|
|
|
|
let url = format!("{}/calendar/delete", self.base_url);
|
|
let request = Request::new_with_str_and_init(&url, &opts)
|
|
.map_err(|e| format!("Request creation failed: {:?}", e))?;
|
|
|
|
request.headers().set("Authorization", &format!("Bearer {}", token))
|
|
.map_err(|e| format!("Authorization header setting failed: {:?}", e))?;
|
|
|
|
request.headers().set("X-CalDAV-Password", password)
|
|
.map_err(|e| format!("Password header setting failed: {:?}", e))?;
|
|
|
|
request.headers().set("Content-Type", "application/json")
|
|
.map_err(|e| format!("Content-Type header setting failed: {:?}", e))?;
|
|
|
|
let resp_value = JsFuture::from(window.fetch_with_request(&request))
|
|
.await
|
|
.map_err(|e| format!("Network request failed: {:?}", e))?;
|
|
|
|
let resp: Response = resp_value.dyn_into()
|
|
.map_err(|e| format!("Response cast failed: {:?}", e))?;
|
|
|
|
let text = JsFuture::from(resp.text()
|
|
.map_err(|e| format!("Text extraction failed: {:?}", e))?)
|
|
.await
|
|
.map_err(|e| format!("Text promise failed: {:?}", e))?;
|
|
|
|
let text_string = text.as_string()
|
|
.ok_or("Response text is not a string")?;
|
|
|
|
if resp.ok() {
|
|
Ok(())
|
|
} else {
|
|
Err(format!("Request failed with status {}: {}", resp.status(), text_string))
|
|
}
|
|
}
|
|
|
|
/// Refresh a single event by UID from the CalDAV server
|
|
pub async fn refresh_event(&self, token: &str, password: &str, uid: &str) -> Result<Option<CalendarEvent>, String> {
|
|
let window = web_sys::window().ok_or("No global window exists")?;
|
|
|
|
let opts = RequestInit::new();
|
|
opts.set_method("GET");
|
|
opts.set_mode(RequestMode::Cors);
|
|
|
|
let url = format!("{}/calendar/events/{}", self.base_url, uid);
|
|
let request = Request::new_with_str_and_init(&url, &opts)
|
|
.map_err(|e| format!("Request creation failed: {:?}", e))?;
|
|
|
|
request.headers().set("Authorization", &format!("Bearer {}", token))
|
|
.map_err(|e| format!("Authorization header setting failed: {:?}", e))?;
|
|
|
|
request.headers().set("X-CalDAV-Password", password)
|
|
.map_err(|e| format!("Password header setting failed: {:?}", e))?;
|
|
|
|
let resp_value = JsFuture::from(window.fetch_with_request(&request))
|
|
.await
|
|
.map_err(|e| format!("Network request failed: {:?}", e))?;
|
|
|
|
let resp: Response = resp_value.dyn_into()
|
|
.map_err(|e| format!("Response cast failed: {:?}", e))?;
|
|
|
|
let text = JsFuture::from(resp.text()
|
|
.map_err(|e| format!("Text extraction failed: {:?}", e))?)
|
|
.await
|
|
.map_err(|e| format!("Text promise failed: {:?}", e))?;
|
|
|
|
let text_string = text.as_string()
|
|
.ok_or("Response text is not a string")?;
|
|
|
|
if resp.ok() {
|
|
let event: Option<CalendarEvent> = serde_json::from_str(&text_string)
|
|
.map_err(|e| format!("JSON parsing failed: {}", e))?;
|
|
Ok(event)
|
|
} else {
|
|
Err(format!("Request failed with status {}: {}", resp.status(), text_string))
|
|
}
|
|
}
|
|
|
|
pub async fn update_series(
|
|
&self,
|
|
token: &str,
|
|
password: &str,
|
|
series_uid: String,
|
|
title: String,
|
|
description: String,
|
|
start_date: String,
|
|
start_time: String,
|
|
end_date: String,
|
|
end_time: String,
|
|
location: String,
|
|
all_day: bool,
|
|
status: String,
|
|
class: String,
|
|
priority: Option<u8>,
|
|
organizer: String,
|
|
attendees: String,
|
|
categories: String,
|
|
reminder: String,
|
|
recurrence: String,
|
|
calendar_path: Option<String>,
|
|
update_scope: String,
|
|
occurrence_date: Option<String>,
|
|
) -> Result<(), String> {
|
|
let window = web_sys::window().ok_or("No global window exists")?;
|
|
|
|
let opts = RequestInit::new();
|
|
opts.set_method("POST");
|
|
opts.set_mode(RequestMode::Cors);
|
|
|
|
let body = serde_json::json!({
|
|
"series_uid": series_uid,
|
|
"title": title,
|
|
"description": description,
|
|
"start_date": start_date,
|
|
"start_time": start_time,
|
|
"end_date": end_date,
|
|
"end_time": end_time,
|
|
"location": location,
|
|
"all_day": all_day,
|
|
"status": status,
|
|
"class": class,
|
|
"priority": priority,
|
|
"organizer": organizer,
|
|
"attendees": attendees,
|
|
"categories": categories,
|
|
"reminder": reminder,
|
|
"recurrence": recurrence,
|
|
"recurrence_days": vec![false; 7], // Default - could be enhanced
|
|
"recurrence_interval": 1_u32, // Default interval
|
|
"recurrence_end_date": None as Option<String>, // No end date by default
|
|
"recurrence_count": None as Option<u32>, // No count limit by default
|
|
"calendar_path": calendar_path,
|
|
"update_scope": update_scope,
|
|
"occurrence_date": occurrence_date
|
|
});
|
|
|
|
let url = format!("{}/calendar/events/series/update", self.base_url);
|
|
|
|
web_sys::console::log_1(&format!("🔄 update_series: Making request to URL: {}", url).into());
|
|
web_sys::console::log_1(&format!("🔄 update_series: Request body: {}", serde_json::to_string_pretty(&body).unwrap_or_default()).into());
|
|
|
|
let body_string = serde_json::to_string(&body)
|
|
.map_err(|e| format!("JSON serialization failed: {}", e))?;
|
|
opts.set_body(&body_string.into());
|
|
let request = Request::new_with_str_and_init(&url, &opts)
|
|
.map_err(|e| format!("Request creation failed: {:?}", e))?;
|
|
|
|
request.headers().set("Authorization", &format!("Bearer {}", token))
|
|
.map_err(|e| format!("Authorization header setting failed: {:?}", e))?;
|
|
|
|
request.headers().set("X-CalDAV-Password", password)
|
|
.map_err(|e| format!("Password header setting failed: {:?}", e))?;
|
|
|
|
request.headers().set("Content-Type", "application/json")
|
|
.map_err(|e| format!("Content-Type header setting failed: {:?}", e))?;
|
|
|
|
let resp_value = JsFuture::from(window.fetch_with_request(&request))
|
|
.await
|
|
.map_err(|e| format!("Network request failed: {:?}", e))?;
|
|
|
|
let resp: Response = resp_value.dyn_into()
|
|
.map_err(|e| format!("Response cast failed: {:?}", e))?;
|
|
|
|
let text = JsFuture::from(resp.text()
|
|
.map_err(|e| format!("Text extraction failed: {:?}", e))?)
|
|
.await
|
|
.map_err(|e| format!("Text promise failed: {:?}", e))?;
|
|
|
|
let text_string = text.as_string()
|
|
.ok_or("Response text is not a string")?;
|
|
|
|
if resp.ok() {
|
|
Ok(())
|
|
} else {
|
|
Err(format!("Request failed with status {}: {}", resp.status(), text_string))
|
|
}
|
|
}
|
|
|
|
}
|
|
|