move rhailib to herolib

rhailib/_archive/engine/examples/calendar/calendar_script.rhai

@@ -0,0 +1,101 @@
+// calendar_script.rhai
+// Example Rhai script for working with Calendar models
+
+// Constants for AttendanceStatus
+const NO_RESPONSE = "NoResponse";
+const ACCEPTED = "Accepted";
+const DECLINED = "Declined";
+const TENTATIVE = "Tentative";
+
+// Create a new calendar using builder pattern
+let my_calendar = new_calendar()
+    .name("Team Calendar")
+    .description("Calendar for team events and meetings");
+
+print(`Created calendar: ${my_calendar.name} (${my_calendar.id})`);
+
+
+// Add attendees to the event
+let alice = new_attendee()
+    .with_contact_id(1)
+    .with_status(NO_RESPONSE);
+let bob = new_attendee()
+    .with_contact_id(2)
+    .with_status(ACCEPTED);
+let charlie = new_attendee()
+    .with_contact_id(3)
+    .with_status(TENTATIVE);
+
+
+// Create a new event using builder pattern
+// Note: Timestamps are in seconds since epoch
+let now = timestamp_now();
+let one_hour = 60 * 60;
+let meeting = new_event()
+    .title("Weekly Sync")
+    .reschedule(now, now + one_hour)
+    .location("Conference Room A")
+    .description("Regular team sync meeting")
+    .add_attendee(alice)
+    .add_attendee(bob)
+    .add_attendee(charlie)
+    .save_event();
+
+print(`Created event: ${meeting.title}`);
+
+meeting.delete_event();
+
+print(`Deleted event: ${meeting.title}`);
+
+// Print attendees info
+let attendees = meeting.attendees;
+print(`Added attendees to the event`);
+
+// Update Charlie's attendee status directly
+meeting.update_attendee_status(3, ACCEPTED);
+print(`Updated Charlie's status to: ${ACCEPTED}`);
+
+// Add the event to the calendar
+my_calendar.add_event_to_calendar(meeting);
+// Print events info
+print(`Added event to calendar`);
+
+// Save the calendar to the database
+let saved_calendar = my_calendar.save_calendar();
+print(`Calendar saved to database with ID: ${saved_calendar.id}`);
+
+// Retrieve the calendar from the database using the ID from the saved calendar
+let retrieved_calendar = get_calendar_by_id(saved_calendar.id);
+if retrieved_calendar != () {
+    print(`Retrieved calendar: ${retrieved_calendar.name}`);
+    print(`Retrieved calendar successfully`);
+} else {
+    print("Failed to retrieve calendar from database");
+}
+
+// List all calendars in the database
+let all_calendars = list_calendars();
+print("\nListing all calendars in database:");
+let calendar_count = 0;
+for calendar in all_calendars {
+    print(`  - Calendar: ${calendar.name} (ID: ${calendar.id})`);
+    calendar_count += 1;
+}
+print(`Total calendars: ${calendar_count}`);
+
+// List all events in the database
+let all_events = list_events();
+print("\nListing all events in database:");
+let event_count = 0;
+for event in all_events {
+    print(`  - Event: ${event.title} (ID: ${event.id})`);
+    event_count += 1;
+}
+print(`Total events: ${event_count}`);
+
+// Helper function to get current timestamp
+fn timestamp_now() {
+    // This would typically be provided by the host application
+    // For this example, we'll use a fixed timestamp
+    1685620800 // June 1, 2023, 12:00 PM
+}

rhailib/_archive/engine/examples/calendar/example.rs

@@ -0,0 +1,70 @@
+use engine::mock_db::create_mock_db;
+use engine::{create_heromodels_engine, eval_file};
+use rhai::Engine;
+
+mod mock;
+use mock::seed_calendar_data;
+
+fn main() -> Result<(), Box<dyn std::error::Error>> {
+    println!("Calendar Rhai Example");
+    println!("=====================");
+
+    // Create a mock database
+    let db = create_mock_db();
+
+    // Seed the database with some initial data
+    seed_calendar_data(db.clone());
+
+    // Create the Rhai engine using our central engine creator
+    let mut engine = create_heromodels_engine(db.clone());
+
+    // Register timestamp helper functions
+    register_timestamp_helpers(&mut engine);
+
+    // Get the path to the script
+    let manifest_dir = std::path::PathBuf::from(env!("CARGO_MANIFEST_DIR"));
+    let script_path = manifest_dir
+        .join("examples")
+        .join("calendar")
+        .join("calendar_script.rhai");
+
+    println!("\nRunning script: {}", script_path.display());
+    println!("---------------------");
+
+    // Run the script
+    match eval_file(&engine, &script_path) {
+        Ok(result) => {
+            if !result.is_unit() {
+                println!("\nScript returned: {:?}", result);
+            }
+            println!("\nScript executed successfully!");
+            Ok(())
+        }
+        Err(err) => {
+            eprintln!("\nError running script: {}", err);
+            Err(Box::new(std::io::Error::new(
+                std::io::ErrorKind::Other,
+                err.to_string(),
+            )))
+        }
+    }
+}
+
+// Register timestamp helper functions with the engine
+fn register_timestamp_helpers(engine: &mut Engine) {
+    use chrono::{TimeZone, Utc};
+
+    // Function to get current timestamp
+    engine.register_fn("timestamp_now", || Utc::now().timestamp() as i64);
+
+    // Function to format a timestamp
+    engine.register_fn("format_timestamp", |ts: i64| {
+        let dt = Utc
+            .timestamp_opt(ts, 0)
+            .single()
+            .expect("Invalid timestamp");
+        dt.format("%Y-%m-%d %H:%M:%S UTC").to_string()
+    });
+
+    println!("Timestamp helper functions registered successfully.");
+}

rhailib/_archive/engine/examples/calendar/mock.rs

@@ -0,0 +1,60 @@
+use chrono::Utc;
+use heromodels::db::hero::OurDB;
+use heromodels::db::{Collection, Db};
+use heromodels::models::calendar::{Calendar, Event};
+use heromodels_core::Model;
+use std::sync::Arc;
+
+/// Seed the mock database with calendar data
+pub fn seed_calendar_data(db: Arc<OurDB>) {
+    // Create a calendar
+    let calendar = Calendar::new(None, "Work Calendar".to_string())
+        .description("My work schedule".to_string());
+
+    // Store the calendar in the database
+    let (calendar_id, mut saved_calendar) = db
+        .collection::<Calendar>()
+        .expect("Failed to get Calendar collection")
+        .set(&calendar)
+        .expect("Failed to store calendar");
+
+    // Create an event
+    let now = Utc::now().timestamp();
+    let end_time = now + 3600; // Add 1 hour in seconds
+
+    let event = Event::new()
+        .title("Team Meeting".to_string())
+        .reschedule(now, end_time)
+        .location("Conference Room A".to_string())
+        .description("Weekly sync".to_string())
+        .build();
+
+    // Store the event in the database first to get its ID
+    let (event_id, saved_event) = db
+        .collection()
+        .expect("Failed to get Event collection")
+        .set(&event)
+        .expect("Failed to store event");
+
+    // Add the event ID to the calendar
+    saved_calendar = saved_calendar.add_event(event_id as i64);
+
+    // Store the updated calendar in the database
+    let (_calendar_id, final_calendar) = db
+        .collection::<Calendar>()
+        .expect("Failed to get Calendar collection")
+        .set(&saved_calendar)
+        .expect("Failed to store calendar");
+
+    println!("Mock database seeded with calendar data:");
+    println!(
+        "  - Added calendar: {} (ID: {})",
+        final_calendar.name,
+        final_calendar.get_id()
+    );
+    println!(
+        "  - Added event: {} (ID: {})",
+        saved_event.title,
+        saved_event.get_id()
+    );
+}