Struct RtmClient 

pub struct RtmClient { /* private fields */ }

The actual messaging client.

Implementations

impl RtmClient

pub fn login(token: &str) -> Result<RtmClient, Error>

Logs in to slack. Call this before calling run. Alternatively use login_and_run.

pub fn run<T: EventHandler>(&self, handler: &mut T) -> Result<(), Error>

Runs the message receive loop

pub fn login_and_run<T: EventHandler>( token: &str, handler: &mut T, ) -> Result<(), Error>

Runs the main loop for the client after logging in to slack.

Returns an error if the process fails at any point, or an Ok(()) on successful close.

Takes an EventHandler implemented by the user which will be called when Events are received.

Examples found in repository

examples/slack_example.rs (line 74)

fn main() {
    let args: Vec<String> = std::env::args().collect();
    let api_key = match args.len() {
        0 | 1 => {
            panic!("No api-key in args! Usage: cargo run --example slack_example -- <api-key>")
        }
        x => args[x - 1].clone(),
    };
    let mut handler = MyHandler;
    let r = RtmClient::login_and_run(&api_key, &mut handler);
    match r {
        Ok(_) => {}
        Err(err) => panic!("Error: {}", err),
    }
}

pub fn sender(&self) -> &Sender

Get a reference thread-safe cloneable message Sender

Examples found in repository

examples/slack_example.rs (line 50)

    fn on_event(&mut self, cli: &RtmClient, event: Event) {
        println!("on_event(event: {:?})", event);
        if let Event::Hello = event {
            // find the general channel id from the `StartResponse`
            let general_channel_id = cli
                .start_response()
                .channels
                .as_ref()
                .and_then(|channels| {
                    channels.iter().find(|chan| match chan.name {
                        None => false,
                        Some(ref name) => name == "general",
                    })
                })
                .and_then(|chan| chan.id.as_ref())
                .expect("general channel not found");
            let _ = cli
                .sender()
                .send_message(&general_channel_id, "Hello world! (rtm)");
            // Send a message over the real time api websocket
        }
    }

pub fn start_response(&self) -> &StartResponse

Returns a reference to the StartResponse.

Examples found in repository

examples/slack_example.rs (line 38)

    fn on_event(&mut self, cli: &RtmClient, event: Event) {
        println!("on_event(event: {:?})", event);
        if let Event::Hello = event {
            // find the general channel id from the `StartResponse`
            let general_channel_id = cli
                .start_response()
                .channels
                .as_ref()
                .and_then(|channels| {
                    channels.iter().find(|chan| match chan.name {
                        None => false,
                        Some(ref name) => name == "general",
                    })
                })
                .and_then(|chan| chan.id.as_ref())
                .expect("general channel not found");
            let _ = cli
                .sender()
                .send_message(&general_channel_id, "Hello world! (rtm)");
            // Send a message over the real time api websocket
        }
    }