926 lines
39 KiB
Rust
926 lines
39 KiB
Rust
|
||
// use futures::lock::Mutex;
|
||
use tokio::sync::mpsc::UnboundedReceiver;
|
||
use tokio::sync::RwLock;
|
||
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::borrow::Borrow;
|
||
use std::borrow::BorrowMut;
|
||
use std::boxed;
|
||
use std::cell::Ref;
|
||
use std::env;
|
||
use dotenv::dotenv;
|
||
|
||
use std::collections::HashMap;
|
||
|
||
use rand::Rng;
|
||
|
||
// Important to use tokios Mutex here since std Mutex doesn't work with async functions
|
||
use tokio::sync::Mutex;
|
||
|
||
|
||
|
||
use crate::core::ratelimiter::RateLimiter;
|
||
use crate::core::ratelimiter;
|
||
|
||
use crate::core::botmodules;
|
||
use crate::core::botmodules::{ModulesManager,BotAction};
|
||
use crate::core::identity::{IdentityManager,Permissible};
|
||
|
||
use std::rc::Rc;
|
||
use std::cell::RefCell;
|
||
use std::sync::Arc;
|
||
// use futures::lock::Mutex;
|
||
|
||
use std::pin::Pin;
|
||
|
||
//use std::borrow::Borrow;
|
||
use core::borrow::Borrow;
|
||
|
||
// pub type BotAR = Arc<RwLock<BotInstance>>;
|
||
use super::botmodules::bot_actions::actions_util::BotAR;
|
||
|
||
|
||
#[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<ChType,RateLimiter>, // used to limit messages sent per channel
|
||
pub ratelimiters : Arc<Mutex<HashMap<ChType,RateLimiter>>>, // used to limit messages sent per channel
|
||
pub client : TwitchIRCClient<TCPTransport<TLS>,StaticLoginCredentials>,
|
||
}
|
||
|
||
impl Chat {
|
||
|
||
|
||
pub fn init(ratelimiters:HashMap<ChType, RateLimiter>,
|
||
client:TwitchIRCClient<TCPTransport<TLS>, StaticLoginCredentials>) -> Chat {
|
||
Chat{
|
||
ratelimiters : Arc::new(Mutex::new(ratelimiters)),
|
||
client : client,
|
||
}
|
||
}
|
||
|
||
// pub fn init_channel(&mut self, chnl:ChType) -> () {
|
||
pub async fn init_channel(&mut self, chnl:ChType) -> () {
|
||
let n = RateLimiter::new();
|
||
self.ratelimiters.lock().await.insert(chnl,n);
|
||
}
|
||
|
||
|
||
|
||
// pub async fn say_in_reply_to(&mut self, msg:& PrivmsgMessage , mut outmsg:String) -> () {
|
||
pub async fn say_in_reply_to(&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 a = Arc::clone(&self.ratelimiters);
|
||
let mut a = a.lock().await;
|
||
|
||
// let contextratelimiter = self.ratelimiters
|
||
let contextratelimiter = a
|
||
// .get_mut()
|
||
.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();
|
||
|
||
|
||
}
|
||
|
||
|
||
}
|
||
|
||
|
||
#[derive(Clone)]
|
||
pub struct BotManagers {
|
||
// pub botmodules : ModulesManager,
|
||
pub identity : Arc<RwLock<IdentityManager>>,
|
||
pub chat : Chat,
|
||
}
|
||
|
||
impl BotManagers {
|
||
|
||
pub fn init(ratelimiters:HashMap<ChType, RateLimiter>,
|
||
client:TwitchIRCClient<TCPTransport<TLS>, StaticLoginCredentials>)
|
||
-> BotManagers {
|
||
// let a = Arc::new(Mutex::new(BotManagers {
|
||
// // botmodules : ModulesManager::init(),
|
||
// identity : Arc::new(Mutex::new(IdentityManager::init())),
|
||
// chat : Chat::init(ratelimiters,client),
|
||
// }));
|
||
// a
|
||
BotManagers {
|
||
// botmodules : ModulesManager::init(),
|
||
identity : Arc::new(RwLock::new(IdentityManager::init())),
|
||
chat : Chat::init(ratelimiters,client),
|
||
}
|
||
}
|
||
|
||
pub fn rIdentity(self) -> Arc<RwLock<IdentityManager>> {
|
||
self.identity
|
||
}
|
||
|
||
// pub fn rChat(&self) -> Arc<Mutex<Chat>> {
|
||
// Arc::new(Mutex::new(self.chat))
|
||
// }
|
||
}
|
||
|
||
|
||
pub struct ArcBox<T: Clone>(pub Arc<Mutex<T>>);
|
||
|
||
impl<T: Clone> ArcBox<T>{
|
||
pub fn inst(&self) -> &Mutex<T> {
|
||
&self.0
|
||
}
|
||
|
||
}
|
||
|
||
//#[derive(Clone)]
|
||
// #[derive(Copy)] // <-- Cannot be derived
|
||
pub struct BotInstance
|
||
{
|
||
pub prefix : char,
|
||
pub bot_channel : ChType,
|
||
// pub incoming_messages : UnboundedReceiver<ServerMessage>,
|
||
pub incoming_messages : Arc<RwLock<UnboundedReceiver<ServerMessage>>>,
|
||
// pub incoming_messages : RefCell<UnboundedReceiver<ServerMessage>>,
|
||
// pub chat : Chat,
|
||
pub botmodules : Arc<ModulesManager>,
|
||
pub twitch_oauth : String,
|
||
pub bot_channels : Vec<ChType>,
|
||
// pub identity : IdentityManager,
|
||
// pub botmgrs : Arc<Mutex<BotManagers>>,
|
||
pub botmgrs : BotManagers,
|
||
}
|
||
|
||
|
||
|
||
impl BotInstance
|
||
{
|
||
|
||
|
||
// pub fn init() -> BotInstance
|
||
// pub fn init() -> Arc<BotInstance>
|
||
pub async 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::<SecureTCPTransport, StaticLoginCredentials>::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 : Arc::new(RwLock::new(incoming_messages)),
|
||
//client : client,
|
||
// chat : Chat {
|
||
// ratelimiters : ratelimiters,
|
||
// client : client,
|
||
// } ,
|
||
botmodules : ModulesManager::init().await,
|
||
twitch_oauth : oauth_token,
|
||
bot_channels : botchannels,
|
||
// identity : IdentityManager::init(),
|
||
botmgrs : BotManagers::init(ratelimiters,client),
|
||
};
|
||
|
||
|
||
//println!("{:?}",b.botmgrs.chat.ratelimiters);
|
||
|
||
|
||
// Arc::new(b)
|
||
//Arc::new(RwLock::new(b))
|
||
b
|
||
}
|
||
|
||
// async fn rcv_helper(self) -> Option<ServerMessage> {
|
||
// // self.incoming_messages.get_mut().recv().await
|
||
// let mut a = self.incoming_messages;
|
||
// a.get_mut().recv().await
|
||
// }
|
||
|
||
// pub async fn runner(mut self) -> () {
|
||
// pub async fn runner(&'static mut self) -> () {
|
||
pub async fn runner(self) -> () {
|
||
|
||
// let bot_am = Arc::new(Mutex::new(self));
|
||
|
||
// let mut boxed_bot = Arc::new(RefCell::new(self)); // <-- [ERROR] Future cannot be handled safely
|
||
|
||
let bot = Arc::new(RwLock::new(self));
|
||
|
||
|
||
let join_handle = tokio::spawn(async move {
|
||
|
||
// let boxed_bot = Arc::new(Mutex::new(self));
|
||
// let mut boxed_bot = Arc::new(self);
|
||
// let bot = Rc::new(RefCell::new(self));
|
||
// let mut bot = Rc::new(RefCell::new(&self));
|
||
//let bot = Arc::new(Mutex::new(&self));
|
||
// let mut boxed_bot = Arc::new(RefCell::new(self));
|
||
// let mut boxed_bot = Arc::new(Mutex::new(self));
|
||
|
||
// while let Some(message) = bot.borrow_mut().incoming_messages.recv().await {
|
||
|
||
// let bot = Arc::clone(&botinit);
|
||
|
||
// while let Some(message) = bot.lock().unwrap().incoming_messages.recv().await {
|
||
//let b = Arc::clone(&bot);
|
||
|
||
// let mut bot = RefCell::new(&self);
|
||
|
||
// let mut bota = bot.clone().borrow();
|
||
|
||
// let boxed_bot = Rc::new(RefCell::new(self));
|
||
// let boxed_bot = Rc::new(self);
|
||
// let boxed_bot = Pin::new(Rc::new(self));
|
||
//let mut boxed_bot = Rc::new(RefCell::new(self));
|
||
// let mut a = (*boxed_bot).clone().into_inner();
|
||
// let mut a = Rc::clone(&boxed_bot).borrow_mut();
|
||
//let mut a = Rc::<Rc<RefCell<BotInstance>>>::Borrow(Rc::clone(&boxed_bot));
|
||
|
||
|
||
// while let Some(message) = Rc::clone(&boxed_bot).into_inner().incoming_messages.recv().await {
|
||
// while let Some(message) = Rc::<BotInstance>::borrow(Rc::<BotInstance>::as_ref(boxed_bot)) {
|
||
|
||
// let a = boxed_bot.borrow();
|
||
|
||
// let boxed_bota = boxed_bot.borrow_mut();
|
||
|
||
// let a = Rc::try_unwrap(boxed_bot).ok().unwrap().into_inner();
|
||
|
||
// let boxed_bot = RefCell::new(Rc::new(self));
|
||
//let boxed_bot = Rc::new(RefCell::new(self));
|
||
// Rc::try_unwrap(boxed_bot).ok().unwrap().into_inner().incoming_messages.recv().await;
|
||
|
||
// let a:Borrowed = boxed_bot.borrow();
|
||
// while let Some(message) = Rc::try_unwrap(boxed_bot).ok().unwrap().into_inner().incoming_messages.recv().await {
|
||
// while let Some(message) = RefCell::new(self).borrow_mut().incoming_messages.recv().await {
|
||
// while let Some(message) = Rc::try_unwrap(boxed_bot).ok().unwrap().into_inner().incoming_messages.recv().await {
|
||
// while let Some(message) = Rc::try_unwrap(boxed_bot.clone()).ok().unwrap().into_inner().rcv_helper().await {
|
||
// while let Some(message) = Rc::try_unwrap(boxed_bot.clone()).ok().unwrap().into_inner().incoming_messages.recv().await {
|
||
// let mut a = Arc::try_unwrap(boxed_bot.clone())
|
||
// .ok().unwrap()
|
||
// .into_inner()
|
||
// .ok().unwrap();
|
||
// let a = Arc::clone(&boxed_bot).into_inner().unwrap().incoming_messages;
|
||
// .into_inner()
|
||
// .try_into().
|
||
// .ok().unwrap();
|
||
// while let Some(message) = a.lock().unwrap().incoming_messages.recv().await {
|
||
// while let Some(message) = a.recv().await {
|
||
// let a = Arc::try_unwrap(boxed_bot.clone()).ok().unwrap();
|
||
// let mut a = Arc::try_unwrap(boxed_bot.clone())
|
||
// .ok()
|
||
// .unwrap();
|
||
// .into_inner()
|
||
// .get_mut()
|
||
// .ok();
|
||
// .unwrap();
|
||
//let mut a = a.lock().unwrap();
|
||
// let a = *a;
|
||
// while let Some(message) = a.lock().ok().unwrap().incoming_messages.recv().await {
|
||
// while let Some(message) = a.get_mut().expect("Error").incoming_messages.recv().await {
|
||
//let tempbot = boxed_bot.clone();
|
||
// while let Some(message) = Arc::try_unwrap(tempbot.clone()).ok().unwrap().into_inner().ok().unwrap().incoming_messages.recv().await {
|
||
// while let Some(message) = Arc::try_unwrap(tempbot.clone()).ok().unwrap().incoming_messages.recv().await {
|
||
// while let Some(message) = boxed_bot.to_owned().incoming_messages.recv().await {
|
||
// while let Some(message) = self.incoming_messages.recv().await {
|
||
// let a:Arc<RefCell<BotInstance>> = Arc::clone(&boxed_bot);
|
||
// while let Some(message) = a.incoming_messages.recv().await {
|
||
// let a = Arc::clone(&boxed_bot).into_inner();
|
||
// while let Some(message) = a.incoming_messages.recv().await {
|
||
// let tempbot = boxed_bot.clone();
|
||
// while let Some(message) = Arc::try_unwrap(tempbot.clone()).ok().unwrap().into_inner().incoming_messages.recv().await {
|
||
|
||
// let tempbot = Arc::clone(&boxed_bot);
|
||
|
||
// while let Some(message) = tempbot.lock().await.incoming_messages.recv().await {
|
||
let a = bot.read().await;
|
||
let mut a = a.incoming_messages.write().await;
|
||
while let Some(message) = a.recv().await {
|
||
|
||
// while let Some(message) = tempbot.into_inner().incoming_messages.recv().await {
|
||
//while let Some(message) = boxed_bot.borrow().incoming_messages.recv().await {
|
||
// // Below can be used to debug if I want to capture all messages
|
||
// println!("Received message: {:?}", message);
|
||
|
||
// let boxed_bot = Arc::new(self);
|
||
|
||
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;
|
||
// bot.into_inner().listener_main_prvmsg(&msg).await;
|
||
//let bot = Rc::<RefCell<&BotInstance>>::clone(&bot);
|
||
|
||
// bot.borrow().listener_main_prvmsg(&msg).await;
|
||
// let mut a = Rc::Clone(&bot);
|
||
// a.borrow_mut().listener_main_prvmsg(&msg).await;
|
||
// bot.borrow_mut().into_inner().listener_main_prvmsg(&msg).await;
|
||
// bot.listener_main_prvmsg(&msg).await;
|
||
// bot.lock().unwrap().listener_main_prvmsg(&msg).await;
|
||
// bot.borrow_mut().listener_main_prvmsg(&msg).await;
|
||
// Rc::clone(&boxed_bot).into_inner().listener_main_prvmsg(&msg).await;
|
||
// boxed_bot.borrow().listener_main_prvmsg(&msg).await;
|
||
// let bottemp = boxed_bot.borrow_mut();
|
||
// let a = **bottemp;
|
||
// Rc::try_unwrap(boxed_bot).ok().unwrap().into_inner().listener_main_prvmsg(&msg).await;
|
||
// Rc::try_unwrap(boxed_bot.clone()).ok().unwrap().into_inner().listener_main_prvmsg(&msg).await;
|
||
// Arc::try_unwrap(boxed_bot.clone()).ok().unwrap().into_inner().ok().unwrap().listener_main_prvmsg(&msg).await;
|
||
// let a = Arc::try_unwrap(boxed_bot.clone()).ok().unwrap();
|
||
// let mut a = a.lock().unwrap();
|
||
// let a = Arc::try_unwrap(boxed_bot.clone()).ok().unwrap();
|
||
// a.listener_main_prvmsg(&msg).await;
|
||
|
||
// (*a).listener_main_prvmsg(&msg).await;
|
||
// let a:Arc<RefCell<BotInstance>> = Arc::clone(&boxed_bot);
|
||
// a.into_inner().listener_main_prvmsg(&msg).await;
|
||
// let tempbot = boxed_bot.clone();
|
||
// Arc::try_unwrap(tempbot.clone()).ok().unwrap().into_inner().listener_main_prvmsg(&msg).await ;
|
||
|
||
// let tempbot = Arc::clone(&tempbot);
|
||
// // let a = tempbot.lock().await;
|
||
// tempbot.lock().await.listener_main_prvmsg(&msg).await;
|
||
// self.listener_main_prvmsg(&msg).await;
|
||
// bot.read().await.listener_main_prvmsg(&msg).await;
|
||
|
||
// let a = bot.read().await;
|
||
// a.listener_main_prvmsg(&msg).await;
|
||
// a.listener_main_prvmsg(&msg).await;
|
||
// let a = bot.read().await;
|
||
BotInstance::listener_main_prvmsg(Arc::clone(&bot), &msg).await;
|
||
// let a = bot.read().await;
|
||
// a.lis
|
||
|
||
|
||
|
||
|
||
|
||
//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();
|
||
|
||
|
||
}
|
||
|
||
|
||
|
||
pub fn get_botmodules(self) -> Arc<ModulesManager> {
|
||
// let a = self.botmodules;
|
||
// Arc::clone(&Arc::new(Mutex::new(self.botmodules)))
|
||
// *self.botmodules
|
||
self.botmodules
|
||
|
||
}
|
||
|
||
// pub fn get_botactions(self:&Self) -> (Self,HashMap<botmodules::ModType,Vec<BotAction>>) {
|
||
// // self.get_botactions()
|
||
// // (*self,(*self).botmodules.rbotactions())
|
||
// (Self { bot_channel},(*self).botmodules.rbotactions())
|
||
// }
|
||
|
||
// pub fn get_botactions(&self) -> (Self,HashMap<botmodules::ModType,Vec<BotAction>>) {
|
||
// pub fn get_botactions(&self) -> HashMap<botmodules::ModType,Vec<BotAction>> {
|
||
// // self.get_botactions()
|
||
// // (*self,(*self).botmodules.rbotactions())
|
||
// // (self,self.botmodules.rbotactions())
|
||
// // (*self).botmodules.rbotactions()
|
||
// // let a = (*self).botmodules.rbotactions();
|
||
// let a =
|
||
// a
|
||
// }
|
||
|
||
pub async fn get_botmgrs(self) -> BotManagers {
|
||
// Arc::new(self.botmgrs)
|
||
// Arc::clone(&Arc::new(Mutex::new(self.botmgrs)))
|
||
let a = self.botmgrs;
|
||
// let a = *a.lock().await;
|
||
// let a = a.rIdentity();
|
||
a
|
||
}
|
||
|
||
// pub fn get_identity(self:&Self) -> (Self,IdentityManager) {
|
||
pub fn get_identity(&self) -> Arc<RwLock<IdentityManager>> {
|
||
// // let a = self.botmgrs;
|
||
// // Arc::clone(&Arc::new(Mutex::new(a.rIdentity())))
|
||
// // let a = self.botmgrs;
|
||
// // Arc::clone(&Arc::new(Mutex::new(a.rIdentity())))
|
||
// let a = self.get_botmgrs().await;
|
||
// let a = a.lock().await;
|
||
// // let a = a.rIdentity();
|
||
// let a = a.clone().identity;
|
||
// a.clone()
|
||
// let id = (*self).botmgrs.identity;
|
||
// id
|
||
Arc::clone(&self.botmgrs.identity)
|
||
}
|
||
|
||
|
||
// pub fn get_prefix(self) -> (Self,char) {
|
||
pub fn get_prefix(&self) -> char {
|
||
// self.prefix.to_string()
|
||
// let a = self.prefix;
|
||
// a.clone().to_string()
|
||
// (self,self.prefix)
|
||
|
||
(*self).prefix
|
||
}
|
||
|
||
// pub fn get_prefix(self:&Self) -> (Self,String) {
|
||
// (*self,(*self).prefix.to_string())
|
||
// }
|
||
// pub fn get_prefix(self:Self) -> (Self,String) {
|
||
// let str1 = self.prefix.to_string();
|
||
// (self,str1)
|
||
// }
|
||
|
||
// pub fn get_prefix(&self) -> String {
|
||
// // self.prefix.to_string()
|
||
// let a = self.prefix;
|
||
// a.clone().to_string()
|
||
// }
|
||
|
||
// pub fn get_prefix(self) -> (Self,String) {
|
||
// // self.prefix.to_string()
|
||
// // let a = self.prefix;
|
||
// // a.clone().to_string()
|
||
// (Self {
|
||
// prefix : self.prefix ,
|
||
// bot_channel : self.bot_channel ,
|
||
// incoming_messages : self.incoming_messages ,
|
||
// botmodules : self.botmodules,
|
||
// twitch_oauth : self.twitch_oauth,
|
||
// bot_channels : self.bot_channels ,
|
||
// // identity : IdentityManager::init(),
|
||
// botmgrs: self.botmgrs ,
|
||
// },
|
||
// self.prefix.to_string())
|
||
// }
|
||
|
||
// -----------------
|
||
// PRIVATE FUNCTIONS
|
||
|
||
|
||
// async fn listener_main_prvmsg(&mut self,msg:PrivmsgMessage) -> () {
|
||
// async fn listener_main_prvmsg(&mut self,msg:&PrivmsgMessage) -> () {
|
||
// async fn listener_main_prvmsg(self,msg:&PrivmsgMessage) -> () {
|
||
// async fn listener_main_prvmsg(self:Arc<Self>,msg:&PrivmsgMessage) -> () {
|
||
pub async fn listener_main_prvmsg(bot:BotAR,msg:&PrivmsgMessage) -> () {
|
||
println!(">> Inner listenermain_prvmsg()");
|
||
|
||
// let a = a;
|
||
// 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)
|
||
|
||
// let botmgr = Rc::new(&self.botmgrs);
|
||
|
||
// let mut boxedbot = Rc::new(RefCell::new(self));
|
||
// let boxed_bot = Rc::new(RefCell::new(self));
|
||
// let boxed_bot = Arc::new(Mutex::new(self));
|
||
// let boxed_bot = Arc::new(self);
|
||
//let boxed_bot = Arc::clone(self);
|
||
// let mut boxed_bot = Arc::new(RefCell::new(self));
|
||
// let mut boxed_bot = Arc::new(RwLock::new(self));
|
||
// let boxed_bot = Arc::new(RwLock::new(self));
|
||
// let boxed_bot = Arc::new(Mutex::new(self));
|
||
//let boxed_bot = Arc::new(Mutex::new(self));
|
||
// let bot = Arc::new(RwLock::new(self));
|
||
|
||
|
||
// for (_m,acts) in &self.botmodules.botactions {
|
||
// for (_m,acts) in &self.botmodules.botactions {
|
||
// for (_m,acts) in bot.into_inner().botmodules.botactions {
|
||
// let mut bot = Rc::clone(&bot);
|
||
// for (_m,acts) in bot.into_inner().botmodules.botactions {
|
||
// for (_m,acts) in bot.into_inner().botmodules.botactions {
|
||
// for (_m,acts) in Rc::try_unwrap(boxed_bot.clone()).ok().unwrap().into_inner().botmodules.botactions {
|
||
// for (_m,acts) in Arc::try_unwrap(boxed_bot.clone()).ok() .unwrap().into_inner().ok().unwrap().botmodules.botactions {
|
||
// for (_m,acts) in Arc::try_unwrap(boxed_bot.clone()).ok().unwrap().botmodules.botactions {
|
||
// for (_m,acts) in Arc::try_unwrap(boxed_bot.clone()).ok().unwrap().into_inner().botmodules.botactions {
|
||
// let a = Arc::try_unwrap(boxed_bot).ok().unwrap().read().unwrap().botmodules.botactions
|
||
// let a = Arc::try_unwrap(boxed_bot.clone()).ok().unwrap();
|
||
// let b = a.read().unwrap();
|
||
// for (_m,acts) in a.read().unwrap().botmodules.botactions {
|
||
// for (_m,acts) in b.rbotmodules().botactions {
|
||
// for (_m,acts) in b.rbotactions() {
|
||
// for (_m,acts) in (*Arc::try_unwrap(boxed_bot.clone()).ok().unwrap().read().unwrap()).rbotactions() {
|
||
// let a = boxed_bot.clone().into_inner();
|
||
// let a = boxed_bot.lock().await;
|
||
//let a = a.lock().in
|
||
// for (_m,acts) in self.rbotactions() {
|
||
// for (_m,acts) in a.read().ok().unwrap().rbotactions() {
|
||
// for (_m,acts) in a.into_inner().ok().unwrap().rbotactions() {
|
||
|
||
// let bot = self;
|
||
// let mut instr:char;
|
||
|
||
// let hacts = self.get_botactions();
|
||
// let hacts = boxed_bot.clone().lock().await.get_botactions();
|
||
// let hacts = bot.read().await.get_botactions();
|
||
let botlock = bot.read().await;
|
||
let hacts = Arc::clone(&botlock.botmodules.botactions);
|
||
// let hacts = hacts.read().await;
|
||
let a = hacts.read().await;
|
||
println!("hacts size : {}",(*a).len());
|
||
|
||
println!(">> Inner listenermain_prvmsg() >> before for loop of bot actions");
|
||
// println!(">> Inner listenermain_prvmsg() >> before for loop of bot actions : {:?}",*hacts);
|
||
// let hacts = hacts
|
||
// let l = *hacts;
|
||
for (_m,acts) in &*hacts.read().await {
|
||
|
||
println!(">> Inner listenermain_prvmsg() >> checking bot actions");
|
||
|
||
|
||
// let bot = bot;
|
||
|
||
for a in acts {
|
||
|
||
println!(">> Inner listenermain_prvmsg() >> checking bot actions >> 2");
|
||
|
||
let _act = 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<UserRole>)
|
||
*/
|
||
|
||
// for v in msg.message_text.split(" ") {
|
||
// println!("args : {v}");
|
||
// }
|
||
|
||
println!("Reviewing internal commands");
|
||
|
||
let inpt = msg.message_text.split("\n").next().expect("ERROR during BotCommand");
|
||
let inpt = msg.message_text.split(" ").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() {
|
||
// if inpt == Rc::try_unwrap(boxed_bot.clone()).ok().unwrap().into_inner().prefix.to_string() + c.command.as_str() {
|
||
// let a = Rc::try_unwrap(boxed_bot.clone()).ok().unwrap().into_inner().prefix.to_string();
|
||
// let a = Arc::try_unwrap(boxed_bot.clone()).ok() .unwrap().into_inner().ok().unwrap().prefix.to_string();
|
||
// let a = Arc::try_unwrap(boxed_bot.clone()).ok().unwrap().prefix.to_string();
|
||
// let a = Arc::try_unwrap(boxed_bot.clone()).ok().unwrap().into_inner().prefix.to_string();
|
||
// let a = Arc::try_unwrap(boxed_bot.clone()).ok().unwrap();
|
||
// let a = (*Arc::try_unwrap(boxed_bot.clone()).ok().unwrap().read().unwrap());
|
||
// let a = (*Arc::try_unwrap(boxed_bot.clone()).ok().unwrap().read().unwrap()).prefix.to_string();
|
||
// let a = self.prefix.to_string();
|
||
// let a = boxed_bot.clone();
|
||
|
||
// if inpt == a.into_inner().ok().unwrap().prefix.to_string() + c.command.as_str() {
|
||
// if inpt == a.into_inner().ok().unwrap().prefix.to_string() + c.command.as_str()
|
||
// let a = boxed_bot.lock().await;
|
||
//
|
||
// if inpt == a.into_inner().prefix.to_string() + c.command.as_str() {
|
||
// if inpt == a.get_prefix() + c.command.as_str() {
|
||
// if inpt == self.get_prefix() + c.command.as_str() {
|
||
// let instr = self.get_prefix();
|
||
// let instr = boxed_bot.clone().lock().await.get_prefix();
|
||
// let instr = bot.read().await.get_prefix();
|
||
let instr = bot.read().await.get_prefix();
|
||
if inpt == String::from(instr) + 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() {
|
||
// if inpt == Rc::try_unwrap(boxed_bot.clone()).ok().unwrap().into_inner().prefix.to_string() + alias.as_str() {
|
||
//
|
||
// if inpt == Arc::try_unwrap(boxed_bot.clone()).ok() .unwrap().into_inner().ok().unwrap().prefix.to_string() + alias.as_str() {
|
||
// Arc::try_unwrap(boxed_bot.clone()).ok().unwrap().into_inner()
|
||
// if inpt == Arc::try_unwrap(boxed_bot.clone()).ok().unwrap().prefix.to_string() + alias.as_str() {
|
||
// if inpt == Arc::try_unwrap(boxed_bot).ok().unwrap().read().unwrap().prefix.to_string() + alias.as_str() {
|
||
// if inpt == self.prefix.to_string() + alias.as_str() {
|
||
// let a = boxed_bot.clone();
|
||
// let a = boxed_bot.lock().await;
|
||
// if inpt == a.into_inner().ok().unwrap().prefix.to_string() + alias.as_str() {
|
||
// if inpt == a.into_inner().prefix.to_string() + alias.as_str() {
|
||
// if inpt == a.get_prefix() + alias.as_str() {
|
||
// if inpt == self.get_prefix() + alias.as_str() {
|
||
// let instr = self.get_prefix();
|
||
// let instr = boxed_bot.clone().lock().await.get_prefix();
|
||
// let instr = bot.read().await.get_prefix();
|
||
let instr = bot.read().await.get_prefix();
|
||
if inpt == String::from(instr) + 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()) {
|
||
// match self.botmgrs.identity.can_user_run_PRVMSG(&msg, c.required_roles.clone()) {
|
||
// match self.botmgrs.identity.clone().can_user_run_PRVMSG(&msg, c.required_roles.clone()) {
|
||
|
||
// let botref = Rc::clone(&botmgr);
|
||
// if let Rc(botmgr) = botref {
|
||
// ()
|
||
// }
|
||
|
||
// match self.botmgrs.identity.clone().can_user_run_PRVMSG(&msg, c.required_roles.clone()) {
|
||
// match boxed_bot.clone().into_inner().botmgrs.identity.clone().can_user_run_PRVMSG(&msg, c.required_roles.clone()) {
|
||
// match Rc::try_unwrap(boxed_bot.clone()).ok().unwrap().into_inner().botmgrs.identity.can_user_run_PRVMSG(&msg, c.required_roles.clone()) {
|
||
//let boxed_bot1 = Arc::clone(&boxed_bot);
|
||
//let a = boxed_bot1.into_inner().ok().unwrap();
|
||
// match boxed_bot1.into_inner().ok().unwrap().botmgrs.identity.can_user_run_PRVMSG(&msg, c.required_roles.clone()) {
|
||
// match Arc::try_unwrap(boxed_bot.clone())
|
||
// .ok()
|
||
// .unwrap().into_inner().ok().unwrap().botmgrs.identity.can_user_run_PRVMSG(&msg, c.required_roles.clone()) {
|
||
// let a = Arc::try_unwrap(boxed_bot.clone()).ok() .unwrap().into_inner();
|
||
// let a = Arc::try_unwrap(boxed_bot.clone()).ok().unwrap();
|
||
// Arc::try_unwrap(boxed_bot.clone()).ok().unwrap().into_inner()
|
||
// match a.botmgrs.identity.can_user_run_PRVMSG(&msg, c.required_roles.clone()) {
|
||
// match Arc::try_unwrap(boxed_bot).ok().unwrap().read().unwrap().botmgrs.identity.can_user_run_PRVMSG(&msg, c.required_roles.clone()) {
|
||
// match self.botmgrs.identity.can_user_run_PRVMSG(&msg, c.required_roles.clone()) {
|
||
// match (boxed_bot.clone().into_inner().ok().unwrap()).botmgrs.identity.can_user_run_PRVMSG(&msg, c.required_roles.clone()) {
|
||
// let a = boxed_bot.clone();
|
||
// let a = boxed_bot.lock().await;
|
||
// // let a = a.read().ok().unwrap().botmgrs.identity;
|
||
// let a = a.get_identity();
|
||
// // let a = a.lock().await.can_user_run_PRVMSG(&msg, c.required_roles.clone()) ;
|
||
|
||
// match a.lock().await.can_user_run_PRVMSG(&msg, c.required_roles.clone()).await {
|
||
|
||
{
|
||
// let le = boxed_bot.lock().await;
|
||
// // let le = le.lock().await;
|
||
// let le = le.get_identity().await;
|
||
// let le = *le;
|
||
// let le = le.lock().await;
|
||
// let le = le.clone();
|
||
// let le = le.can_user_run_PRVMSG(&msg, c.required_roles.clone()).await;
|
||
// let le = self.get_identity().await.can_user_run_PRVMSG(&msg, c.required_roles.clone()).await;
|
||
// let le = self.botmgrs;
|
||
// let le = le.identity;
|
||
// let (bot,id) = self.get_identity();
|
||
// let id = boxed_bot.clone().lock().await.get_identity();
|
||
// let id = bot.read().await.get_identity();
|
||
// let id = Arc::clone(&self.botmgrs.identity);
|
||
// let id = id.write().await;
|
||
// let id = &(*self.get_identity());
|
||
let botlock = bot.read().await;
|
||
let id = botlock.get_identity();
|
||
let id = id.read().await;
|
||
let eval= id.can_user_run_PRVMSG(&msg, c.required_roles.clone()).await;
|
||
match eval {
|
||
// Ok(Permissible::Allow) => (),
|
||
Permissible::Allow => {
|
||
println!("Executed as permissible");
|
||
// c.execute(bot, msg.clone()).await;
|
||
// if let bot = Rc::<RefCell<BotInstance>>::clone(*bot) {
|
||
// c.execute(bot, msg.clone()).await;
|
||
// }
|
||
// let boxed_bot = Arc::new(RwLock::new(self));
|
||
// c.execute(boxed_bot.clone(), msg.clone()).await;
|
||
// c.execute(self, msg.clone()).await;
|
||
//let mut a = *self;
|
||
// c.execute(self, msg.clone());
|
||
// let a = self;
|
||
// let a = Arc::clone(&self);
|
||
let a = Arc::clone(&bot);
|
||
// let a = Arc::clone(&bot);
|
||
c.execute(a, msg.clone());
|
||
|
||
}
|
||
Permissible::Block => {
|
||
println!("User Not allowed to run command")
|
||
},
|
||
// _ => (),
|
||
};
|
||
|
||
// c.execute(self.chat.clone(), msg.clone()).await;
|
||
}
|
||
}
|
||
},
|
||
|
||
crate::core::botmodules::BotAction::L(l) => {
|
||
// if let bot = Rc::clone(&bot) {
|
||
// l.into_inner().execute(bot, msg.clone()).await
|
||
// }
|
||
//let bot = Rc::clone(&bot).into_inner();
|
||
// l.execute(boxed_bot.clone(), msg.clone()).await
|
||
// let boxed_bot = Arc::new(RwLock::new(self));
|
||
// l.execute(boxed_bot.clone(), msg.clone()).await;
|
||
// let a = Arc::clone(&self);
|
||
let a = Arc::clone(&bot);
|
||
l.execute(a, msg.clone());
|
||
},
|
||
|
||
_ => (),
|
||
};
|
||
}
|
||
};
|
||
|
||
// // [ ] There should be a BotCommand Listener to check for prefixes ran
|
||
|
||
println!("End of Separate Listener Main prvmsg");
|
||
|
||
// self
|
||
// bot
|
||
|
||
}
|
||
|
||
|
||
|
||
}
|
||
|
||
|
||
|
||
|
||
|
||
|
||
// ======================================
|
||
// ======================================
|
||
// ======================================
|
||
// ======================================
|
||
|
||
// UNIT TEST MODULES
|
||
|
||
|
||
|
||
|
||
|
||
#[cfg(test)]
|
||
mod tests {
|
||
fn always() {
|
||
assert_eq!(1,1);
|
||
}
|
||
}
|