399 lines
13 KiB
Rust
399 lines
13 KiB
Rust
use chrono::{Utc, Duration};
|
|
use herodb::db::{DBBuilder, GetId};
|
|
use herodb::models::mcc::{
|
|
Calendar, Event,
|
|
Email, Attachment, Envelope,
|
|
Contact, Message
|
|
};
|
|
use herodb::models::circle::Circle;
|
|
use std::path::PathBuf;
|
|
use std::fs;
|
|
|
|
fn main() -> Result<(), Box<dyn std::error::Error>> {
|
|
println!("DB Example MCC: Mail, Calendar, Contacts with Group Support");
|
|
println!("=======================================================");
|
|
|
|
// Create a temporary directory for the database
|
|
let db_path = PathBuf::from("/tmp/dbexample_mcc");
|
|
if db_path.exists() {
|
|
fs::remove_dir_all(&db_path)?;
|
|
}
|
|
fs::create_dir_all(&db_path)?;
|
|
println!("Database path: {:?}", db_path);
|
|
|
|
// Create a database instance with our models registered
|
|
let db = DBBuilder::new(&db_path)
|
|
.register_type::<Calendar>("calendar")
|
|
.register_type::<Event>("event")
|
|
.register_type::<Email>("email")
|
|
.register_type::<Contact>("contact")
|
|
.register_type::<Message>("message")
|
|
.register_model::<Circle>() // Circle still uses the Model trait
|
|
.build()?;
|
|
|
|
println!("\n1. Creating Circles (Groups)");
|
|
println!("---------------------------");
|
|
|
|
// Create circles (groups)
|
|
let work_circle = Circle::new(
|
|
1,
|
|
"Work".to_string(),
|
|
"Work-related communications".to_string()
|
|
);
|
|
|
|
let family_circle = Circle::new(
|
|
2,
|
|
"Family".to_string(),
|
|
"Family communications".to_string()
|
|
);
|
|
|
|
let friends_circle = Circle::new(
|
|
3,
|
|
"Friends".to_string(),
|
|
"Friends communications".to_string()
|
|
);
|
|
|
|
// Insert circles
|
|
db.set::<Circle>(&work_circle)?;
|
|
db.set::<Circle>(&family_circle)?;
|
|
db.set::<Circle>(&friends_circle)?;
|
|
|
|
println!("Created circles:");
|
|
println!(" - Circle #{}: {}", work_circle.id, work_circle.name);
|
|
println!(" - Circle #{}: {}", family_circle.id, family_circle.name);
|
|
println!(" - Circle #{}: {}", friends_circle.id, friends_circle.name);
|
|
|
|
println!("\n2. Creating Contacts with Group Support");
|
|
println!("------------------------------------");
|
|
|
|
// Create contacts
|
|
let mut john = Contact::new(
|
|
1,
|
|
"John".to_string(),
|
|
"Doe".to_string(),
|
|
"john.doe@example.com".to_string(),
|
|
"work".to_string()
|
|
);
|
|
john.add_group(work_circle.id);
|
|
|
|
let mut alice = Contact::new(
|
|
2,
|
|
"Alice".to_string(),
|
|
"Smith".to_string(),
|
|
"alice.smith@example.com".to_string(),
|
|
"family".to_string()
|
|
);
|
|
alice.add_group(family_circle.id);
|
|
|
|
let mut bob = Contact::new(
|
|
3,
|
|
"Bob".to_string(),
|
|
"Johnson".to_string(),
|
|
"bob.johnson@example.com".to_string(),
|
|
"friends".to_string()
|
|
);
|
|
bob.add_group(friends_circle.id);
|
|
bob.add_group(work_circle.id); // Bob is both a friend and a work contact
|
|
|
|
// Insert contacts
|
|
db.set_any::<Contact>(&john, "contact")?;
|
|
db.set_any::<Contact>(&alice, "contact")?;
|
|
db.set_any::<Contact>(&bob, "contact")?;
|
|
|
|
println!("Created contacts:");
|
|
println!(" - {}: {} (Groups: {:?})", john.full_name(), john.email, john.groups);
|
|
println!(" - {}: {} (Groups: {:?})", alice.full_name(), alice.email, alice.groups);
|
|
println!(" - {}: {} (Groups: {:?})", bob.full_name(), bob.email, bob.groups);
|
|
|
|
println!("\n3. Creating Calendars with Group Support");
|
|
println!("-------------------------------------");
|
|
|
|
// Create calendars
|
|
let mut work_calendar = Calendar::new(
|
|
1,
|
|
"Work Calendar".to_string(),
|
|
"Work-related events".to_string()
|
|
);
|
|
work_calendar.add_group(work_circle.id);
|
|
|
|
let mut personal_calendar = Calendar::new(
|
|
2,
|
|
"Personal Calendar".to_string(),
|
|
"Personal events".to_string()
|
|
);
|
|
personal_calendar.add_group(family_circle.id);
|
|
personal_calendar.add_group(friends_circle.id);
|
|
|
|
// Insert calendars
|
|
db.set_any::<Calendar>(&work_calendar, "calendar")?;
|
|
db.set_any::<Calendar>(&personal_calendar, "calendar")?;
|
|
|
|
println!("Created calendars:");
|
|
println!(" - {}: {} (Groups: {:?})", work_calendar.id, work_calendar.title, work_calendar.groups);
|
|
println!(" - {}: {} (Groups: {:?})", personal_calendar.id, personal_calendar.title, personal_calendar.groups);
|
|
|
|
println!("\n4. Creating Events with Group Support");
|
|
println!("----------------------------------");
|
|
|
|
// Create events
|
|
let now = Utc::now();
|
|
let tomorrow = now + Duration::days(1);
|
|
let next_week = now + Duration::days(7);
|
|
|
|
let mut work_meeting = Event::new(
|
|
1,
|
|
work_calendar.id,
|
|
"Team Meeting".to_string(),
|
|
"Weekly team sync".to_string(),
|
|
"Conference Room A".to_string(),
|
|
tomorrow,
|
|
tomorrow + Duration::hours(1),
|
|
"organizer@example.com".to_string()
|
|
);
|
|
work_meeting.add_group(work_circle.id);
|
|
work_meeting.add_attendee(john.email.clone());
|
|
work_meeting.add_attendee(bob.email.clone());
|
|
|
|
let mut family_dinner = Event::new(
|
|
2,
|
|
personal_calendar.id,
|
|
"Family Dinner".to_string(),
|
|
"Weekly family dinner".to_string(),
|
|
"Home".to_string(),
|
|
next_week,
|
|
next_week + Duration::hours(2),
|
|
"me@example.com".to_string()
|
|
);
|
|
family_dinner.add_group(family_circle.id);
|
|
family_dinner.add_attendee(alice.email.clone());
|
|
|
|
// Insert events
|
|
db.set_any::<Event>(&work_meeting, "event")?;
|
|
db.set_any::<Event>(&family_dinner, "event")?;
|
|
|
|
println!("Created events:");
|
|
println!(" - {}: {} on {} (Groups: {:?})",
|
|
work_meeting.id,
|
|
work_meeting.title,
|
|
work_meeting.start_time.format("%Y-%m-%d %H:%M"),
|
|
work_meeting.groups
|
|
);
|
|
println!(" - {}: {} on {} (Groups: {:?})",
|
|
family_dinner.id,
|
|
family_dinner.title,
|
|
family_dinner.start_time.format("%Y-%m-%d %H:%M"),
|
|
family_dinner.groups
|
|
);
|
|
|
|
println!("\n5. Creating Emails with Group Support");
|
|
println!("----------------------------------");
|
|
|
|
// Create emails
|
|
let mut work_email = Email::new(
|
|
1,
|
|
101,
|
|
1,
|
|
"INBOX".to_string(),
|
|
"Here are the meeting notes from yesterday's discussion.".to_string()
|
|
);
|
|
work_email.add_group(work_circle.id);
|
|
|
|
let work_attachment = Attachment {
|
|
filename: "meeting_notes.pdf".to_string(),
|
|
content_type: "application/pdf".to_string(),
|
|
hash: "abc123def456".to_string(),
|
|
size: 1024,
|
|
};
|
|
work_email.add_attachment(work_attachment);
|
|
|
|
let work_envelope = Envelope {
|
|
date: now.timestamp(),
|
|
subject: "Meeting Notes".to_string(),
|
|
from: vec!["john.doe@example.com".to_string()],
|
|
sender: vec!["john.doe@example.com".to_string()],
|
|
reply_to: vec!["john.doe@example.com".to_string()],
|
|
to: vec!["me@example.com".to_string()],
|
|
cc: vec!["bob.johnson@example.com".to_string()],
|
|
bcc: vec![],
|
|
in_reply_to: "".to_string(),
|
|
message_id: "msg123@example.com".to_string(),
|
|
};
|
|
work_email.set_envelope(work_envelope);
|
|
|
|
let mut family_email = Email::new(
|
|
2,
|
|
102,
|
|
2,
|
|
"INBOX".to_string(),
|
|
"Looking forward to seeing you at dinner next week!".to_string()
|
|
);
|
|
family_email.add_group(family_circle.id);
|
|
|
|
let family_envelope = Envelope {
|
|
date: now.timestamp(),
|
|
subject: "Family Dinner".to_string(),
|
|
from: vec!["alice.smith@example.com".to_string()],
|
|
sender: vec!["alice.smith@example.com".to_string()],
|
|
reply_to: vec!["alice.smith@example.com".to_string()],
|
|
to: vec!["me@example.com".to_string()],
|
|
cc: vec![],
|
|
bcc: vec![],
|
|
in_reply_to: "".to_string(),
|
|
message_id: "msg456@example.com".to_string(),
|
|
};
|
|
family_email.set_envelope(family_envelope);
|
|
|
|
// Insert emails
|
|
db.set_any::<Email>(&work_email, "email")?;
|
|
db.set_any::<Email>(&family_email, "email")?;
|
|
|
|
println!("Created emails:");
|
|
println!(" - From: {}, Subject: {} (Groups: {:?})",
|
|
work_email.envelope.as_ref().unwrap().from[0],
|
|
work_email.envelope.as_ref().unwrap().subject,
|
|
work_email.groups
|
|
);
|
|
println!(" - From: {}, Subject: {} (Groups: {:?})",
|
|
family_email.envelope.as_ref().unwrap().from[0],
|
|
family_email.envelope.as_ref().unwrap().subject,
|
|
family_email.groups
|
|
);
|
|
|
|
println!("\n6. Creating Messages (Chat) with Group Support");
|
|
println!("-----------------------------------------");
|
|
|
|
// Create messages
|
|
let mut work_chat = Message::new(
|
|
1,
|
|
"thread_work_123".to_string(),
|
|
"john.doe@example.com".to_string(),
|
|
"Can we move the meeting to 3pm?".to_string()
|
|
);
|
|
work_chat.add_group(work_circle.id);
|
|
work_chat.add_recipient("me@example.com".to_string());
|
|
work_chat.add_recipient("bob.johnson@example.com".to_string());
|
|
|
|
let mut friends_chat = Message::new(
|
|
2,
|
|
"thread_friends_456".to_string(),
|
|
"bob.johnson@example.com".to_string(),
|
|
"Are we still on for the game this weekend?".to_string()
|
|
);
|
|
friends_chat.add_group(friends_circle.id);
|
|
friends_chat.add_recipient("me@example.com".to_string());
|
|
friends_chat.add_reaction("👍".to_string());
|
|
|
|
// Insert messages
|
|
db.set_any::<Message>(&work_chat, "message")?;
|
|
db.set_any::<Message>(&friends_chat, "message")?;
|
|
|
|
println!("Created messages:");
|
|
println!(" - From: {}, Content: {} (Groups: {:?})",
|
|
work_chat.sender_id,
|
|
work_chat.content,
|
|
work_chat.groups
|
|
);
|
|
println!(" - From: {}, Content: {} (Groups: {:?}, Reactions: {:?})",
|
|
friends_chat.sender_id,
|
|
friends_chat.content,
|
|
friends_chat.groups,
|
|
friends_chat.meta.reactions
|
|
);
|
|
|
|
println!("\n7. Demonstrating Utility Methods");
|
|
println!("------------------------------");
|
|
|
|
// Filter contacts by group
|
|
println!("\nFiltering contacts by work group (ID: {}):", work_circle.id);
|
|
let all_contacts = db.list_any::<Contact>()?;
|
|
for contact in all_contacts {
|
|
if contact.filter_by_groups(&[work_circle.id]) {
|
|
println!(" - {} ({})", contact.full_name(), contact.email);
|
|
}
|
|
}
|
|
|
|
// Search emails by subject
|
|
println!("\nSearching emails with subject containing 'Meeting':");
|
|
let all_emails = db.list_any::<Email>()?;
|
|
for email in all_emails {
|
|
if email.search_by_subject("Meeting") {
|
|
println!(" - Subject: {}, From: {}",
|
|
email.envelope.as_ref().unwrap().subject,
|
|
email.envelope.as_ref().unwrap().from[0]
|
|
);
|
|
}
|
|
}
|
|
|
|
// Get events for a calendar
|
|
println!("\nGetting events for Work Calendar (ID: {}):", work_calendar.id);
|
|
let all_events = db.list_any::<Event>()?;
|
|
let work_events: Vec<Event> = all_events
|
|
.into_iter()
|
|
.filter(|event| event.calendar_id == work_calendar.id)
|
|
.collect();
|
|
for event in work_events {
|
|
println!(" - {}: {} on {}",
|
|
event.id,
|
|
event.title,
|
|
event.start_time.format("%Y-%m-%d %H:%M")
|
|
);
|
|
}
|
|
|
|
// Get attendee contacts for an event
|
|
println!("\nGetting attendee contacts for Team Meeting (ID: {}):", work_meeting.id);
|
|
let all_contacts = db.list_any::<Contact>()?;
|
|
let attendee_contacts: Vec<Contact> = all_contacts
|
|
.into_iter()
|
|
.filter(|contact| work_meeting.attendees.contains(&contact.email))
|
|
.collect();
|
|
for contact in attendee_contacts {
|
|
println!(" - {} ({})", contact.full_name(), contact.email);
|
|
}
|
|
|
|
// Convert email to message
|
|
println!("\nConverting work email to message:");
|
|
let email_to_message = work_email.to_message(3, "thread_converted_789".to_string());
|
|
println!(" - Original Email Subject: {}", work_email.envelope.as_ref().unwrap().subject);
|
|
println!(" - Converted Message Content: {}", email_to_message.content.split('\n').next().unwrap_or(""));
|
|
println!(" - Converted Message Groups: {:?}", email_to_message.groups);
|
|
|
|
// Insert the converted message
|
|
db.set_any::<Message>(&email_to_message, "message")?;
|
|
|
|
println!("\n8. Relationship Management");
|
|
println!("------------------------");
|
|
|
|
// Get the calendar for an event
|
|
println!("\nGetting calendar for Family Dinner event (ID: {}):", family_dinner.id);
|
|
let event_calendar = db.get_any::<Calendar>(family_dinner.calendar_id)?;
|
|
println!(" - Calendar: {} ({})", event_calendar.title, event_calendar.description);
|
|
|
|
// Get events for a contact
|
|
println!("\nGetting events where John Doe is an attendee:");
|
|
let all_events = db.list_any::<Event>()?;
|
|
let john_events: Vec<Event> = all_events
|
|
.into_iter()
|
|
.filter(|event| event.attendees.contains(&john.email))
|
|
.collect();
|
|
for event in john_events {
|
|
println!(" - {}: {} on {}",
|
|
event.id,
|
|
event.title,
|
|
event.start_time.format("%Y-%m-%d %H:%M")
|
|
);
|
|
}
|
|
|
|
// Get messages in the same thread
|
|
println!("\nGetting all messages in the work chat thread:");
|
|
let all_messages = db.list_any::<Message>()?;
|
|
let thread_messages: Vec<Message> = all_messages
|
|
.into_iter()
|
|
.filter(|message| message.thread_id == work_chat.thread_id)
|
|
.collect();
|
|
for message in thread_messages {
|
|
println!(" - From: {}, Content: {}", message.sender_id, message.content);
|
|
}
|
|
|
|
println!("\nExample completed successfully!");
|
|
Ok(())
|
|
} |