bot.rs

extern crate discord;
extern crate time;
extern crate rand;

use discord::{Discord, State};
use discord::model::{Event, Member};
use std::env;
use time::{SteadyTime, Duration};
use rand::Rng;

fn main() {
    //log into discord using bot token
    let discord = Discord::from_bot_token(
        &env::var("DISCORD_TOKEN").expect("Expected token"),
    ).expect("Login failed");

    let (mut connection, ready) = discord.connect().expect("Connection failed");
    let mut state = State::new(ready);
    println!("Logged in as {}.", state.user().username);

    //set up stuff for "Daily Arbitrary Ranking" functionality
    let one_day = Duration::seconds(86400);
    let mut current_arbitrary_ranking = Vec::<Member>::new();
    let mut prev_ranking_time = SteadyTime::now() - one_day;
    let mut rng = rand::thread_rng();

    loop {

        let event = match connection.recv_event() {
            Ok(e) => e,
            Err(err) => {
                println!("Received error: {:?}", err);
                break;
            }
        };

        state.update(&event);
        match event {
            Event::MessageCreate(message) => {
                let tokens = message.content.split(' ').collect::<Vec<_>>();
                if tokens.len() > 0 {
                    match tokens[0] {
                        "!test" => {
                            let _ = discord.send_message(message.channel_id,
                                "Frank end your turn.", "", false).unwrap();
                        },
                        "!ar" => {
                            //if a day or more has passed since the last ranking, then recalculate a new one
                            if prev_ranking_time + one_day <= SteadyTime::now() {
                                let _ = discord.send_message(message.channel_id,
                                    "Calculating new arbitrary rankings...", "", false).unwrap();
                                prev_ranking_time = SteadyTime::now();
                                current_arbitrary_ranking.clear();
                                let _ = discord.send_message(message.channel_id,
                                    "Downloading member information...", "", false).unwrap();
                                connection.sync_servers(&state.all_servers());
                                connection.download_all_members(&mut state);
                                while state.unknown_members() > 0 {} //block until all members have been downloaded
                                for s in state.servers() {
                                    for m in s.members.iter().cloned() {
                                        if !m.user.bot && m.roles.len() > 0 {
                                            current_arbitrary_ranking.push(m);
                                        }
                                    }
                                }
                                rng.shuffle(&mut current_arbitrary_ranking);
                            }
                            let _ = discord.send_message(message.channel_id,
                                "Today's Arbitrary Ranking of Users (Top 10)", "", false).unwrap();
                            let mut output = String::from("");
                            for i in 0..10 {
                                output = format!("{}{}: {}\n", output, i + 1,
                                    str::replace(&current_arbitrary_ranking[i].user.name, "\"", ""));
                            }

                            let _ = discord.send_message(message.channel_id,
                                output.as_str(), "", false).unwrap();
                        },
                        _ => {},
                    }
                }
            },
            _ => {},
        }
    }
}