Business

let profile = client.get_business_profile(&jid).await?;

pub async fn get_business_profile(
    &self,
    jid: &Jid,
) -> Result<Option<BusinessProfile>, IqError>

let jid: Jid = "15551234567@s.whatsapp.net".parse()?;

if let Some(profile) = client.get_business_profile(&jid).await? {
    println!("Description: {}", profile.description);
    
    if let Some(email) = &profile.email {
        println!("Email: {}", email);
    }
    
    for site in &profile.website {
        println!("Website: {}", site);
    }
    
    if let Some(addr) = &profile.address {
        println!("Address: {}", addr);
    }
    
    for category in &profile.categories {
        println!("Category: {} (ID: {})", category.name, category.id);
    }
    
    if let Some(tz) = &profile.business_hours.timezone {
        println!("Timezone: {}", tz);
    }
    
    if let Some(configs) = &profile.business_hours.business_config {
        for config in configs {
            println!(
                "  {}: {} ({}–{})",
                config.day_of_week,
                config.mode,
                config.open_time.as_deref().unwrap_or("N/A"),
                config.close_time.as_deref().unwrap_or("N/A"),
            );
        }
    }
} else {
    println!("Not a business account");
}

pub struct BusinessProfile {
    pub wid: Option<Jid>,
    pub description: String,
    pub email: Option<String>,
    pub website: Vec<String>,
    pub categories: Vec<BusinessCategory>,
    pub address: Option<String>,
    pub business_hours: BusinessHours,
}

pub struct BusinessCategory {
    pub id: String,
    pub name: String,
}

pub struct BusinessHours {
    pub timezone: Option<String>,
    pub business_config: Option<Vec<BusinessHoursConfig>>,
}

pub struct BusinessHoursConfig {
    pub day_of_week: String,
    pub mode: String,
    pub open_time: Option<String>,
    pub close_time: Option<String>,
}

use wacore::types::events::{Event, BusinessStatusUpdate, BusinessUpdateType};

match event {
    Event::BusinessStatusUpdate(update) => {
        match update.update_type {
            BusinessUpdateType::VerifiedNameChanged => {
                println!("Verified name: {:?}", update.verified_name);
            }
            BusinessUpdateType::ProfileUpdated => {
                println!("Business profile updated for {}", update.jid);
            }
            BusinessUpdateType::RemovedAsBusiness => {
                println!("{} is no longer a business account", update.jid);
            }
            BusinessUpdateType::ProductsUpdated => {
                println!("Products updated: {:?}", update.product_ids);
            }
            BusinessUpdateType::CollectionsUpdated => {
                println!("Collections updated: {:?}", update.collection_ids);
            }
            BusinessUpdateType::SubscriptionsUpdated => {
                println!("Subscriptions: {:?}", update.subscriptions);
            }
            _ => {}
        }
    }
    _ => {}
}

let phones = ["15551234567"];
let results = client.contacts().get_info(&phones).await?;

for contact in &results {
    if contact.is_business {
        println!("{} is a business account", contact.jid);
    }
}