Newsletters (channels)

let newsletter = client.newsletter();

let created = client.newsletter()
    .create("My Channel", Some("Channel description"))
    .await?;

println!("Created: {} ({})", created.name, created.jid);
println!("Invite code: {:?}", created.invite_code);

let newsletters = client.newsletter().list_subscribed().await?;

for nl in &newsletters {
    println!("{}: {} ({} subscribers)",
        nl.jid, nl.name, nl.subscriber_count);
}

let metadata = client.newsletter().get_metadata(&newsletter_jid).await?;

println!("Name: {}", metadata.name);
println!("Description: {:?}", metadata.description);
println!("Subscribers: {}", metadata.subscriber_count);
println!("Verification: {:?}", metadata.verification);
println!("State: {:?}", metadata.state);

let metadata = client.newsletter()
    .get_metadata_by_invite("invite-code-here")
    .await?;

println!("Found: {} ({})", metadata.name, metadata.jid);

let joined = client.newsletter().join(&newsletter_jid).await?;

println!("Joined '{}' as {:?}", joined.name, joined.role);

client.newsletter().leave(&newsletter_jid).await?;

let updated = client.newsletter()
    .update(
        &newsletter_jid,
        Some("New Channel Name"),
        Some("Updated description"),
    )
    .await?;

println!("Updated: {}", updated.name);

use whatsapp_rust::waproto::whatsapp as wa;

let mut message = wa::Message::default();
message.conversation = Some("Hello subscribers!".to_string());

let msg_id = client.send_message(newsletter_jid, message).await?;

println!("Sent message: {}", msg_id);

use whatsapp_rust::NewsletterMessageType;
use wacore::types::message::EditAttribute;

// Fetch the latest 50 messages
let messages = client.newsletter()
    .get_messages(&newsletter_jid, 50, None)
    .await?;

for msg in &messages {
    println!("ID: {}, time: {}, type: {:?}",
        msg.server_id, msg.timestamp, msg.message_type);

    match msg.edit {
        EditAttribute::AdminEdit => println!("  (edited)"),
        EditAttribute::AdminRevoke => println!("  (revoked)"),
        _ => {}
    }

    if let Some(decoded) = &msg.message {
        if let Some(text) = &decoded.conversation {
            println!("  Text: {}", text);
        }
    }

    for reaction in &msg.reactions {
        println!("  {} x{}", reaction.code, reaction.count);
    }

    if msg.message_type == NewsletterMessageType::Poll {
        for vote in &msg.votes {
            println!("  poll option {}: {}", hex::encode(vote.option_hash), vote.count);
        }
    }

    if let Some(forwards) = msg.forwards_count {
        println!("  forwards: {}", forwards);
    }
}

// Get messages before a specific server_id
let older = client.newsletter()
    .get_messages(&newsletter_jid, 20, Some(last_server_id))
    .await?;

let duration = client.newsletter()
    .subscribe_live_updates(&newsletter_jid)
    .await?;

println!("Subscribed for {}s", duration);

use wacore::types::events::Event;

Event::NewsletterLiveUpdate(update) => {
    println!("Newsletter {} updated:", update.newsletter_jid);
    for msg in &update.messages {
        println!("  Message {}: {:?}", msg.server_id,
            msg.reactions.iter()
                .map(|r| format!("{} x{}", r.code, r.count))
                .collect::<Vec<_>>()
        );
        for vote in &msg.votes {
            println!("    poll option {}: {}", hex::encode(vote.option_hash), vote.count);
        }
        if let Some(forwards) = msg.forwards_count {
            println!("    forwards: {}", forwards);
        }
    }
}

use whatsapp_rust::NewsletterError;

match client.newsletter().get_metadata(&jid).await {
    Ok(metadata) => println!("Found: {}", metadata.name),
    Err(NewsletterError::NotFound(jid)) => eprintln!("No channel at {}", jid),
    Err(NewsletterError::InvalidRequest(msg)) => eprintln!("Invalid request: {}", msg),
    Err(e) => eprintln!("Error: {}", e),
}