Struct serenity::builder::CreateInvite

pub struct CreateInvite(pub HashMap<&'static str, Value>);

A builder to create a RichInvite for use via GuildChannel::create_invite.

This is a structured and cleaner way of creating an invite, as all parameters are optional.

Examples

Create an invite with a max age of 3600 seconds and 10 max uses:

struct Handler;

impl EventHandler for Handler {
    fn message(&self, context: Context, msg: Message) {
        if msg.content == "!createinvite" {
            let channel = match context.cache.read().guild_channel(msg.channel_id) {
                Some(channel) => channel,
                None => {
                    let _ = msg.channel_id.say(&context, "Error creating invite");
                    return;
                },
            };

            let channel = channel.read();

            let creation = channel.create_invite(&context, |i| {
                i.max_age(3600).max_uses(10)
            });

            let invite = match creation {
                Ok(invite) => invite,
                Err(why) => {
                    println!("Err creating invite: {:?}", why);
                    if let Err(why) = msg.channel_id.say(&context, "Error creating invite") {
                        println!("Err sending err msg: {:?}", why);
                    }

                    return;
                },
            };

            let content = format!("Here's your invite: {}", invite.url());
            let _ = msg.channel_id.say(&context, &content);
        }
    }
}

let mut client = Client::new("token", Handler).unwrap();

client.start().unwrap();

Implementations

impl CreateInvite

pub fn max_age(&mut self, max_age: u64) -> &mut Self

The duration that the invite will be valid for.

Set to 0 for an invite which does not expire after an amount of time.

Defaults to 86400, or 24 hours.

Examples

Create an invite with a max age of 3600 seconds, or 1 hour:

let invite = channel.create_invite(context, |i| {
    i.max_age(3600)
})?;

pub fn max_uses(&mut self, max_uses: u64) -> &mut Self

The number of uses that the invite will be valid for.

Set to 0 for an invite which does not expire after a number of uses.

Defaults to 0.

Examples

Create an invite with a max use limit of 5:

let invite = channel.create_invite(context, |i| {
    i.max_uses(5)
})?;

pub fn temporary(&mut self, temporary: bool) -> &mut Self

Whether an invite grants a temporary membership.

Defaults to false.

Examples

Create an invite which is temporary:

let invite = channel.create_invite(context, |i| {
    i.temporary(true)
})?;

pub fn unique(&mut self, unique: bool) -> &mut Self

Whether or not to try to reuse a similar invite.

Defaults to false.

Examples

Create an invite which is unique:

let invite = channel.create_invite(context, |i| {
    i.unique(true)
})?;

Trait Implementations

impl Clone for CreateInvite

fn clone(&self) -> CreateInvite

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for CreateInvite

fn fmt(&self, f: &mut Formatter) -> Result

Formats the value using the given formatter.

impl Default for CreateInvite

fn default() -> CreateInvite

Creates a builder with default values, setting validate to null.

Examples

Create a default CreateInvite builder:

use serenity::builder::CreateInvite;

let invite_builder = CreateInvite::default();