2020-05-06 19:11:04 +02:00
use serenity ::model ::id ::{ GuildId , RoleId } ;
use serenity ::model ::prelude ::* ;
use serenity ::prelude ::* ;
use serenity ::Client ;
use std ::collections ::HashMap ;
use std ::fs ::File ;
use std ::io ::{ self , BufRead , BufReader } ;
#[ macro_use ]
extern crate lazy_static ;
struct Handler ;
impl EventHandler for Handler {
fn voice_state_update (
& self ,
ctx : Context ,
guild_id : Option < GuildId > ,
old : Option < VoiceState > ,
new : VoiceState ,
) {
2020-05-08 16:45:13 +02:00
if guild_id . is_none ( ) | | ! ROLES_BY_SERVER . contains_key ( & guild_id . unwrap ( ) ) {
return ;
}
let gid = guild_id . unwrap ( ) ;
let rid = ROLES_BY_SERVER . get ( & gid ) . unwrap ( ) ;
if let Ok ( guild ) = PartialGuild ::get ( & ctx . http , gid ) {
let mut roles = guild
. member ( & ctx . http , new . user_id )
. expect ( " could not retrieve member " )
. roles ;
// user just joined the VC -> add the role
if old . is_none ( ) {
roles . push ( * rid ) ;
// user is no longer in VC -> remove the role
} else if new . channel_id . is_none ( ) {
roles . retain ( | r | r ! = rid ) ;
}
if let Err ( e ) = guild . edit_member ( & ctx . http , new . user_id , | m | m . roles ( roles ) ) {
println! (
" Could not edit member {} of guild {}, {} " ,
new . user_id , gid , e
) ;
2020-05-06 19:11:04 +02:00
}
}
}
}
lazy_static! {
static ref ROLES_BY_SERVER : HashMap < GuildId , RoleId > = {
std ::env ::args ( )
. nth ( 1 )
. expect (
"
Please specify at least one guild - role tuple like
` . / bot ' guild_id :role_id ; guild_id2 :role_id2 ' ` " ,
)
. split ( ';' )
. map ( | s | s . splitn ( 2 , ':' ) )
. map ( | mut s | {
(
GuildId {
0 : s . next ( ) . unwrap ( ) . parse ( ) . unwrap ( ) ,
} ,
RoleId {
0 : s . next ( ) . unwrap ( ) . parse ( ) . unwrap ( ) ,
} ,
)
} )
. collect ( )
} ;
}
fn main ( ) {
println! ( " Running with config for {} servers " , ROLES_BY_SERVER . len ( ) ) ;
let mut client = Client ::new ( read_token ( ) . expect ( " Could not read secret " ) , Handler )
. expect ( " Could not create new client. " ) ;
client . start ( ) . expect ( " Could not start client. " ) ;
}
fn read_token ( ) -> io ::Result < String > {
let reader = BufReader ::new ( File ::open ( " secret " ) ? ) ;
reader . lines ( ) . next ( ) . unwrap ( )
}