use tokio::sync::mpsc::UnboundedReceiver; use twitch_irc::login::StaticLoginCredentials; use twitch_irc::ClientConfig; use twitch_irc::SecureTCPTransport; use twitch_irc::TwitchIRCClient; use twitch_irc::message::PrivmsgMessage; use twitch_irc::message::ServerMessage; use twitch_irc::transport::tcp::TCPTransport; use twitch_irc::transport::tcp::TLS; use std::env; use dotenv::dotenv; use std::collections::HashMap; use rand::Rng; use crate::core::ratelimiter::RateLimiter; use crate::core::ratelimiter; use crate::core::botmodules; use crate::core::botmodules::ModulesManager; use crate::core::identity::{IdentityManager,Permissible}; #[derive(Debug, PartialEq, Eq, Hash, Clone)] pub enum ChType { Channel(String), } pub use ChType::Channel; pub enum ModType { BotModule(String), } pub use ModType::BotModule; #[derive(Clone)] pub struct Chat { pub ratelimiters : HashMap, // used to limit messages sent per channel pub client : TwitchIRCClient,StaticLoginCredentials>, } impl Chat { pub fn init_channel(&mut self, chnl:ChType) -> () { let n = RateLimiter::new(); self.ratelimiters.insert(chnl,n); } pub async fn say_in_reply_to(&mut self, msg:& PrivmsgMessage , mut outmsg:String) -> () { /* formats message before sending to TwitchIRC - [x] Custom String Formatting (e.g., adding random black spaces) - [x] Ratelimiter Handling - [ ] Checkf if BotActions is Enabled & Caller is Allowed to Run */ // self.client.say_in_reply_to(msg,outmsg).await.unwrap(); // // let contextratelimiter = ratelimiters.get_mut(&msg.channel_login).expect("ERROR: Issue with Rate limiters"); let contextratelimiter = self.ratelimiters .get_mut(&Channel(String::from(&msg.channel_login))) .expect("ERROR: Issue with Rate limiters"); // let contextratelimiter = self.ratelimiters.get(&msg.channel_login).expect("ERROR: Issue with Rate limiters"); match contextratelimiter.check_limiter() { ratelimiter::LimiterResp::Allow => { let maxblanks = rand::thread_rng().gen_range(1..=20); //let mut outmsg = "GotTrolled ".to_owned(); // let mut outmsg = "annytfLurk ".to_owned(); for _i in 1..maxblanks { let blankspace: &str = "󠀀"; outmsg.push_str(blankspace); } // client.say_in_reply_to(&msg,outmsg).await.unwrap(); self.client.say_in_reply_to(msg,outmsg).await.unwrap(); println!("(#{}) > {}", msg.channel_login, "rate limit counter increase"); contextratelimiter.increment_counter(); println!("{:?}",self.ratelimiters); }, ratelimiter::LimiterResp::Skip => { (); // do nothing otherwise } } } async fn say(&self, _:String, _:String) -> () { // more info https://docs.rs/twitch-irc/latest/twitch_irc/client/struct.TwitchIRCClient.html#method.say // self.client.say(msg,outmsg).await.unwrap(); } async fn me(&self, _:String, _:String) -> () { // more info https://docs.rs/twitch-irc/latest/twitch_irc/client/struct.TwitchIRCClient.html#method.say // self.client.me(msg,outmsg).await.unwrap(); } async fn me_in_reply_to(&self, _:String, _:String) -> () { // more info https://docs.rs/twitch-irc/latest/twitch_irc/client/struct.TwitchIRCClient.html#method.say // self.client.me(msg,outmsg).await.unwrap(); } } pub struct BotManagers { pub botmodules : ModulesManager, pub identity : IdentityManager, } impl BotManagers { pub fn init() -> BotManagers { BotManagers { botmodules : ModulesManager::init(), identity : IdentityManager::init(), } } } pub struct BotInstance { prefix : char, bot_channel : ChType, pub incoming_messages : UnboundedReceiver, pub chat : Chat, // pub botmodules : ModulesManager, twitch_oauth : String, pub bot_channels : Vec, // pub identity : IdentityManager, pub botmgrs : BotManagers, } impl BotInstance { pub fn init() -> BotInstance { dotenv().ok(); let login_name = env::var("login_name").unwrap().to_owned(); let oauth_token = env::var("access_token").unwrap().to_owned(); let prefix = env::var("prefix").unwrap().to_owned().chars().next().expect("ERROR : when defining prefix"); /* Vector of channels to join */ let mut botchannels = Vec::new(); for chnl in env::var("bot_channels").unwrap().split(',') { // println!("(Env Var # {})",chnl); botchannels.push(Channel(String::from(chnl))); } let config = ClientConfig::new_simple( StaticLoginCredentials::new(login_name.to_owned(), Some(oauth_token.to_owned())) ); let (incoming_messages, client) = TwitchIRCClient::::new(config); // hashmap for channels and their associated ratelimiters let mut ratelimiters = HashMap::new(); for Channel(chnl) in &botchannels { // For each channel in botchannels client.join(chnl.to_owned()).unwrap(); // ratelimiters are a hashmap of channel and a corresponding rate limiter let n = RateLimiter::new(); ratelimiters.insert(Channel(String::from(chnl)),n); //self.chat.ratelimiters.insert(Channel(String::from(chnl)),n); } // let bm = &mut ModulesManager::init(); let b = BotInstance { prefix : prefix, bot_channel : Channel(login_name) , incoming_messages : incoming_messages, //client : client, chat : Chat { ratelimiters : ratelimiters, client : client, } , // botmodules : ModulesManager::init(), twitch_oauth : oauth_token, bot_channels : botchannels, // identity : IdentityManager::init(), botmgrs : BotManagers::init(), }; println!("{:?}",b.chat.ratelimiters); b } pub async fn runner(mut self) -> () { let join_handle = tokio::spawn(async move { while let Some(message) = self.incoming_messages.recv().await { // Below can be used to debug if I want to capture all messages // println!("Received message: {:?}", message); match message { ServerMessage::Notice(msg) => { // if let Some(chnl) = msg.channel_login { // println!("NOTICE : (#{}) {}", chnl, msg.message_text); // } match msg.channel_login { Some(chnl) => println!("NOTICE : (#{}) {}", chnl, msg.message_text), None => println!("NOTICE : {}", msg.message_text), } } ServerMessage::Privmsg(msg) => { println!("(#{}) {}: {}", msg.channel_login, msg.sender.name, msg.message_text); println!("Privmsg section"); // b.listener_main_prvmsg(&msg); self.listener_main_prvmsg(msg).await; // - BotCommand listener should likely need to be called within the above }, ServerMessage::Whisper(msg) => { println!("(w) {}: {}", msg.sender.name, msg.message_text); }, ServerMessage::Join(msg) => { println!("JOINED: {}", msg.channel_login); }, ServerMessage::Part(msg) => { println!("PARTED: {}", msg.channel_login); }, _ => {} } } }); join_handle.await.unwrap(); } // ----------------- // PRIVATE FUNCTIONS // async fn listener_main_prvmsg(&mut self,msg:PrivmsgMessage) -> () { async fn listener_main_prvmsg(&self,msg:PrivmsgMessage) -> () { // println!("(#{}) {}: {}", msg.channel_login, msg.sender.name, msg.message_text); // // [ ] Need to run through all Listener Bodies for Enabled Modules for the context of the message (e.g., ModStatus is Enabled in the context for the channel) for (_m,acts) in &self.botmgrs.botmodules.botactions { for a in acts { match a { crate::core::botmodules::BotAction::C(c) => { /* BotCommand handling - - [x] Checks if the input message is a prefix with command name or alias - [ ] Validate User can run based on identityModule(From_Bot)::can_user_run( _usr:String, _channelname:ChType, _chat_badge:ChatBadge, _cmdreqroles:Vec) */ let inpt = msg.message_text.split("\n").next().expect("ERROR during BotCommand"); // [x] Check if a bot command based on ... // [x] prefix + command let mut confirmed_bot_command = false; if inpt == self.prefix.to_string() + c.command.as_str() { confirmed_bot_command = true; } // [x] prefix + alias for alias in &c.alias { if inpt == self.prefix.to_string() + alias.as_str() { confirmed_bot_command = true; } } if confirmed_bot_command { // self.identity.clone().can_user_run_PRVMSG(&msg, c.required_roles.clone()); // [ ] Around here, validate if permissable before executing // match self.identity.clone().can_user_run_PRVMSG(&msg, c.required_roles.clone()) { // Ok(Permissible::Allow) => c.execute(self.chat.clone(), msg.clone()).await, // Ok(Permissible::Block) => println!("User Not allowed to run command"), // _ => (), // } match self.botmgrs.identity.to_owned().can_user_run_PRVMSG(&msg, c.required_roles.clone()) { // Ok(Permissible::Allow) => (), Permissible::Allow => { println!("Executed as permissible"); c.execute(self.chat.clone(), msg.clone()).await; } Permissible::Block => println!("User Not allowed to run command"), // _ => (), } // c.execute(self.chat.clone(), msg.clone()).await; } }, crate::core::botmodules::BotAction::L(l) => l.execute(self.chat.clone(), msg.clone()).await, _ => (), } } }; // // [ ] There should be a BotCommand Listener to check for prefixes ran println!("End of Separate Listener Main prvmsg"); } } // ====================================== // ====================================== // ====================================== // ====================================== // UNIT TEST MODULES #[cfg(test)] mod tests { fn always() { assert_eq!(1,1); } }