133 lines
6.2 KiB
Rust
133 lines
6.2 KiB
Rust
use chrono::{Duration, Utc};
|
|
use heromodels::db::{Collection, Db};
|
|
use heromodels::models::calendar::{Attendee, AttendanceStatus, Calendar, Event};
|
|
use heromodels_core::Model;
|
|
|
|
fn main() {
|
|
// Create a new DB instance, reset before every run
|
|
let db_path = "/tmp/ourdb_calendar_example";
|
|
let db = heromodels::db::hero::OurDB::new(db_path, true).expect("Can create DB");
|
|
|
|
println!("Hero Models - Calendar Usage Example");
|
|
println!("====================================");
|
|
|
|
// --- Create Attendees ---
|
|
let attendee1 = Attendee::new("user_123".to_string())
|
|
.status(AttendanceStatus::Accepted);
|
|
let attendee2 = Attendee::new("user_456".to_string())
|
|
.status(AttendanceStatus::Tentative);
|
|
let attendee3 = Attendee::new("user_789".to_string()); // Default NoResponse
|
|
|
|
// --- Create Events ---
|
|
let now = Utc::now();
|
|
let event1 = Event::new(
|
|
"event_alpha".to_string(),
|
|
"Team Meeting",
|
|
now + Duration::seconds(3600), // Using Duration::seconds for more explicit chrono 0.4 compatibility
|
|
now + Duration::seconds(7200),
|
|
)
|
|
.description("Weekly sync-up meeting.")
|
|
.location("Conference Room A")
|
|
.add_attendee(attendee1.clone())
|
|
.add_attendee(attendee2.clone());
|
|
|
|
let event2 = Event::new(
|
|
"event_beta".to_string(),
|
|
"Project Brainstorm",
|
|
now + Duration::days(1),
|
|
now + Duration::days(1) + Duration::seconds(5400), // 90 minutes
|
|
)
|
|
.description("Brainstorming session for new project features.")
|
|
.add_attendee(attendee1.clone())
|
|
.add_attendee(attendee3.clone());
|
|
|
|
let event3_for_calendar2 = Event::new(
|
|
"event_gamma".to_string(),
|
|
"Client Call",
|
|
now + Duration::days(2),
|
|
now + Duration::days(2) + Duration::seconds(3600)
|
|
);
|
|
|
|
// --- Create Calendars ---
|
|
// Note: Calendar::new directly returns Calendar, no separate .build() step like the user example.
|
|
|
|
// Create a calendar with auto-generated ID
|
|
let calendar1 = Calendar::new(None, "Work Calendar")
|
|
.description("Calendar for all work-related events.")
|
|
.add_event(event1.clone())
|
|
.add_event(event2.clone());
|
|
|
|
// Create a calendar with auto-generated ID (explicit IDs are no longer supported)
|
|
let calendar2 = Calendar::new(None, "Personal Calendar")
|
|
.add_event(event3_for_calendar2.clone());
|
|
|
|
|
|
// --- Store Calendars in DB ---
|
|
let cal_collection = db.collection::<Calendar>().expect("can open calendar collection");
|
|
|
|
let (_, calendar1) = cal_collection.set(&calendar1).expect("can set calendar1");
|
|
let (_, calendar2) = cal_collection.set(&calendar2).expect("can set calendar2");
|
|
|
|
println!("Created calendar1 (ID: {}): Name - '{}'", calendar1.get_id(), calendar1.name);
|
|
println!("Created calendar2 (ID: {}): Name - '{}'", calendar2.get_id(), calendar2.name);
|
|
|
|
// --- Retrieve a Calendar by ID ---
|
|
let stored_calendar1_opt = cal_collection.get_by_id(calendar1.get_id()).expect("can try to load calendar1");
|
|
assert!(stored_calendar1_opt.is_some(), "Calendar1 should be found in DB");
|
|
let mut stored_calendar1 = stored_calendar1_opt.unwrap();
|
|
|
|
println!("\nRetrieved calendar1 from DB: Name - '{}', Events count: {}", stored_calendar1.name, stored_calendar1.events.len());
|
|
assert_eq!(stored_calendar1.name, "Work Calendar");
|
|
assert_eq!(stored_calendar1.events.len(), 2);
|
|
assert_eq!(stored_calendar1.events[0].title, "Team Meeting");
|
|
|
|
// --- Modify a Calendar (Reschedule an Event) ---
|
|
let event_id_to_reschedule = event1.id.as_str();
|
|
let new_start_time = now + Duration::seconds(10800); // 3 hours from now
|
|
let new_end_time = now + Duration::seconds(14400); // 4 hours from now
|
|
|
|
stored_calendar1 = stored_calendar1.update_event(event_id_to_reschedule, |event_to_update| {
|
|
println!("Rescheduling event '{}'...", event_to_update.title);
|
|
event_to_update.reschedule(new_start_time, new_end_time)
|
|
});
|
|
|
|
let rescheduled_event = stored_calendar1.events.iter().find(|e| e.id == event_id_to_reschedule)
|
|
.expect("Rescheduled event should exist");
|
|
assert_eq!(rescheduled_event.start_time, new_start_time);
|
|
assert_eq!(rescheduled_event.end_time, new_end_time);
|
|
println!("Event '{}' rescheduled in stored_calendar1.", rescheduled_event.title);
|
|
|
|
// --- Store the modified calendar ---
|
|
let (_, mut stored_calendar1) = cal_collection.set(&stored_calendar1).expect("can set modified calendar1");
|
|
let re_retrieved_calendar1_opt = cal_collection.get_by_id(calendar1.get_id()).expect("can try to load modified calendar1");
|
|
let re_retrieved_calendar1 = re_retrieved_calendar1_opt.unwrap();
|
|
let re_retrieved_event = re_retrieved_calendar1.events.iter().find(|e| e.id == event_id_to_reschedule)
|
|
.expect("Rescheduled event should exist in re-retrieved calendar");
|
|
assert_eq!(re_retrieved_event.start_time, new_start_time, "Reschedule not persisted correctly");
|
|
|
|
println!("\nModified and re-saved calendar1. Rescheduled event start time: {}", re_retrieved_event.start_time);
|
|
|
|
// --- Add a new event to an existing calendar ---
|
|
let event4_new = Event::new(
|
|
"event_delta".to_string(),
|
|
"1-on-1",
|
|
now + Duration::days(3),
|
|
now + Duration::days(3) + Duration::seconds(1800) // 30 minutes
|
|
);
|
|
stored_calendar1 = stored_calendar1.add_event(event4_new);
|
|
assert_eq!(stored_calendar1.events.len(), 3);
|
|
let (_, stored_calendar1) = cal_collection.set(&stored_calendar1).expect("can set calendar1 after adding new event");
|
|
println!("Added new event '1-on-1' to stored_calendar1. Total events: {}", stored_calendar1.events.len());
|
|
|
|
// --- Delete a Calendar ---
|
|
cal_collection.delete_by_id(calendar2.get_id()).expect("can delete calendar2");
|
|
let deleted_calendar2_opt = cal_collection.get_by_id(calendar2.get_id()).expect("can try to load deleted calendar2");
|
|
assert!(deleted_calendar2_opt.is_none(), "Calendar2 should be deleted from DB");
|
|
|
|
println!("\nDeleted calendar2 (ID: {}) from DB.", calendar2.get_id());
|
|
println!("Calendar model DB Prefix: {}", Calendar::db_prefix());
|
|
|
|
println!("\nExample finished. DB stored at {}", db_path);
|
|
println!("To clean up, you can manually delete the directory: {}", db_path);
|
|
}
|