408 lines
No EOL
13 KiB
Rust
408 lines
No EOL
13 KiB
Rust
use core::{panic};
|
|
use std::error::Error;
|
|
|
|
use std::collections::HashMap;
|
|
|
|
use crate::core::identity;
|
|
|
|
|
|
/*
|
|
|
|
ModulesManager is used to manage Modules and BotActions associated with those modules
|
|
|
|
pub struct ModulesManager {
|
|
statusdb: HashMap<ModType,Vec<ModStatusType>>,
|
|
botactions: HashMap<ModType,Vec<BotAction>>,
|
|
}
|
|
|
|
- statusdb: HashMap<ModType,Vec<ModStatusType>> - Defines Modules and their ModStatusType (e.g., Enabled at an Instance level, Disabled at a Channel Level)
|
|
- botactions: HashMap<ModType,Vec<BotAction>> - Defines Modules and their BotActions (e.g., BotCommand , Listener, Routine)
|
|
|
|
Example
|
|
{
|
|
ModulesManager {
|
|
statusdb: {BotModule("experiments 004"): [Enabled(Instance)]},
|
|
botactions: {BotModule("experiments 004"): [C(BotCommand { module: BotModule("experiments 004"), command: "DUPCMD4", alias: ["DUPALIAS4A", "DUPALIAS4B"], help: "DUPCMD4 tester" })]} }
|
|
}
|
|
|
|
*/
|
|
|
|
#[derive(Debug, PartialEq, Eq, Hash, Clone)]
|
|
pub enum ModType {
|
|
BotModule(String),
|
|
}
|
|
|
|
pub use ModType::BotModule;
|
|
|
|
#[derive(Debug, PartialEq, Eq, Hash, Clone)]
|
|
pub enum ChType {
|
|
Channel(String),
|
|
}
|
|
|
|
|
|
pub use ChType::Channel;
|
|
use twitch_irc::message::PrivmsgMessage;
|
|
|
|
use crate::core::botinstance::{self, BotInstance};
|
|
|
|
|
|
#[derive(Debug)]
|
|
enum StatusLvl {
|
|
Instance,
|
|
Ch(ChType),
|
|
}
|
|
|
|
#[derive(Debug)]
|
|
pub enum ModStatusType {
|
|
Enabled(StatusLvl),
|
|
Disabled(StatusLvl),
|
|
}
|
|
|
|
pub enum BotAction
|
|
{
|
|
C(BotCommand),
|
|
L(Listener),
|
|
R(Routine),
|
|
}
|
|
|
|
impl BotAction {
|
|
pub async fn execute(&self,m:botinstance::Chat,n:PrivmsgMessage){
|
|
|
|
match self {
|
|
BotAction::L(a) => a.execute(m,n).await,
|
|
BotAction::C(a) => a.execute(m,n).await,
|
|
_ => (),
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
pub trait BotActionTrait
|
|
{
|
|
fn add_to_bot(self, bot:BotInstance);
|
|
fn add_to_modmgr(self,modmgr:&mut ModulesManager);
|
|
}
|
|
|
|
|
|
pub struct BotCommand {
|
|
pub module : ModType,
|
|
pub command : String, // command call name
|
|
pub alias : Vec<String>, // String of alternative names
|
|
// bot_prefix : char, // although should be global?
|
|
pub exec_body : bot_actions::actions_util::ExecBody,
|
|
pub help : String,
|
|
pub required_roles : Vec<identity::UserRole>,
|
|
}
|
|
|
|
impl BotCommand
|
|
{
|
|
pub async fn execute(&self,m:botinstance::Chat,n:PrivmsgMessage){
|
|
(self.exec_body)(m,n).await;
|
|
}
|
|
}
|
|
|
|
|
|
impl BotActionTrait for BotCommand
|
|
{
|
|
fn add_to_bot(self, mut bot:BotInstance) {
|
|
let mgr = &mut bot.botmgrs.botmodules;
|
|
self.add_to_modmgr(mgr);
|
|
}
|
|
|
|
fn add_to_modmgr(self, modmgr:&mut ModulesManager) {
|
|
modmgr.add_botaction(self.module.clone(), BotAction::C(self))
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
pub mod bot_actions {
|
|
|
|
pub mod actions_util {
|
|
|
|
use std::future::Future;
|
|
use std::boxed::Box;
|
|
use std::pin::Pin;
|
|
|
|
use crate::core::botinstance::Chat;
|
|
use twitch_irc::message::PrivmsgMessage;
|
|
|
|
pub type ExecBody = Box<dyn Fn(Chat,PrivmsgMessage) -> Pin<Box<dyn Future<Output=()> + Send>> + Send + Sync>;
|
|
//pub type ExecBody<F> = Box<dyn Fn(Chat,PrivmsgMessage) -> Pin<Box<dyn Future<Output=F> + Send>> + Send + Sync>;
|
|
|
|
//pub fn asyncbox<T,F>(f: fn(Chat,PrivmsgMessage) -> T) -> ExecBody<F>
|
|
pub fn asyncbox<T>(f: fn(Chat,PrivmsgMessage) -> T) -> ExecBody
|
|
where
|
|
T: Future<Output=()> + Send + 'static,
|
|
{
|
|
Box::new(move |a,b| Box::pin(f(a,b)))
|
|
}
|
|
}
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
pub struct Listener
|
|
{
|
|
pub module : ModType,
|
|
pub name : String,
|
|
pub exec_body : bot_actions::actions_util::ExecBody,
|
|
pub help : String
|
|
}
|
|
|
|
impl Listener
|
|
{
|
|
pub async fn execute(&self,m:botinstance::Chat,n:PrivmsgMessage){
|
|
(self.exec_body)(m,n).await;
|
|
}
|
|
}
|
|
|
|
impl BotActionTrait for Listener
|
|
{
|
|
fn add_to_bot(self, mut bot:BotInstance) {
|
|
|
|
let mgr = &mut bot.botmgrs.botmodules;
|
|
|
|
self.add_to_modmgr(mgr);
|
|
}
|
|
|
|
fn add_to_modmgr(self, modmgr:&mut ModulesManager) {
|
|
modmgr.add_botaction(self.module.clone(), BotAction::L(self))
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
#[derive(Debug)]
|
|
struct Routine {}
|
|
|
|
pub struct ModulesManager
|
|
{
|
|
statusdb: HashMap<ModType,Vec<ModStatusType>>,
|
|
pub botactions: HashMap<ModType,Vec<BotAction>>,
|
|
}
|
|
|
|
impl ModulesManager
|
|
{
|
|
|
|
pub fn init() -> ModulesManager
|
|
{
|
|
|
|
|
|
let m = HashMap::new();
|
|
let act = HashMap::new();
|
|
|
|
let mut mgr = ModulesManager {
|
|
statusdb : m,
|
|
botactions : act,
|
|
};
|
|
|
|
// initialize core modules
|
|
crate::core::identity::init(&mut mgr);
|
|
|
|
// initialize custom crate modules
|
|
crate::modules::init(&mut mgr);
|
|
|
|
|
|
|
|
println!(">> Modules Manager : End of Init");
|
|
|
|
mgr
|
|
}
|
|
|
|
pub fn modstatus(&self, _:ModType, _:ChType) -> ModStatusType {
|
|
// Example usage : botmanager.modstatus(
|
|
// BotModule("GambaCore"),
|
|
// Channel("modulatingforce")
|
|
// )
|
|
// - The ModStatusType checks in the context of the given channel ,
|
|
// but also validates based on wheher the module is disabled at a bot instance
|
|
// level as well
|
|
ModStatusType::Enabled(StatusLvl::Instance)
|
|
}
|
|
|
|
|
|
pub fn togglestatus(&self, _:ModType, _:ChType) -> ModStatusType {
|
|
// enables or disables based on current status
|
|
ModStatusType::Enabled(StatusLvl::Instance)
|
|
}
|
|
|
|
|
|
pub fn setstatus(&self, _:ModType, _:ModStatusType) -> Result<&str,Box<dyn Error>> {
|
|
// sets the status based given ModSatusType
|
|
// e.g., b.setstatus(BodModule("GambaCore"), Enabled(Channel("modulatingforce"))).expect("ERROR")
|
|
Ok("")
|
|
}
|
|
|
|
//pub fn add_botaction(mut self, in_module:ModType, in_action:BotAction ) -> ModulesManager {
|
|
// pub fn add_botaction(mut self, in_module:ModType, in_action:BotAction<F> ) -> ModulesManager<F> {
|
|
//pub fn add_botaction(&mut self, in_module:ModType, in_action:BotAction ) -> () {
|
|
pub fn add_botaction(&mut self, in_module:ModType, in_action:BotAction ) {
|
|
/*
|
|
adds a BotAction to the Modules Manager - This will require a BotModule passed as well
|
|
This will including the logic of a valid add
|
|
If it fails to add, either a PANIC or some default coded business rules that handles the botaction add
|
|
For example, this Should PANIC (ideally Panic?) if it does not successfully add a bot module
|
|
-- Being unable to indicates a Programming/Developer code logic issue : They cannot add botactions that already exists (?)
|
|
-- In particular to BotCommands, which must have Unique command call names and aliases that to not conflict with any other
|
|
already BotCommand added name or alias
|
|
Other types might be fine? For example, if 2 modules have their own listeners but each have the name "targetchatter" ,
|
|
both would be called separately, even if they both have the same or different logic
|
|
*/
|
|
|
|
// let newlistener = Listener {
|
|
// // module : BotModule(String::from("experiments").to_owned()),
|
|
// module : in_module.clone(),
|
|
// name : String::from("socklistener"),
|
|
// help : String::from("This will listen and react to sock randomly"),
|
|
// };
|
|
|
|
|
|
// As a Demonstration, the listener's Module is added and Enabled at Instance level
|
|
|
|
|
|
// [x] Before Adding, validate the following :
|
|
// - If BotAction to Add is a BotCommand , In Module Manager DB (botactions),
|
|
// Check All Other BotAction Command Names & Aliases to ensure they don't conflict
|
|
|
|
fn find_conflict_module(mgr:& ModulesManager, act:& BotAction) -> Option<ModType>
|
|
{
|
|
|
|
// Some(BotModule(String::from("GambaCore")))
|
|
|
|
|
|
// match act {
|
|
// BotAction::C(c) => {
|
|
// Some(BotModule(String::from("GambaCore")))
|
|
// },
|
|
// BotAction::L(l) => None,
|
|
// BotAction::R(r) => None,
|
|
// }
|
|
|
|
if let BotAction::C(incmd) = act {
|
|
|
|
// let n = & mgr.botactions;
|
|
|
|
let d = &mgr.botactions;
|
|
|
|
for (module,moduleactions) in d {
|
|
|
|
|
|
for modact in moduleactions.iter() {
|
|
if let BotAction::C(dbcmd) = &modact {
|
|
// At this point, there is an command incmd and looked up dbcmd
|
|
|
|
// [x] check if given botcommand c.command:String conflicts with any in botactions
|
|
|
|
if incmd.command.to_lowercase() == dbcmd.command.to_lowercase() {
|
|
// Returning State - with the identified module
|
|
// return Some((module.clone(),BotAction::C(*dbcmd.clone())));
|
|
// return Some(incmd); // for some reason I keep getting issues
|
|
//return Some(BotModule(String::from("GambaCore"))); // works
|
|
return Some(module.clone()); // works
|
|
// return Some(dbcmd.clone());
|
|
}
|
|
|
|
for a in &dbcmd.alias {
|
|
if incmd.command.to_lowercase() == a.to_lowercase() {
|
|
// Returning State - with the identified module
|
|
// return Some((module.clone(),BotAction::C(dbcmd)));
|
|
return Some(module.clone()); // works
|
|
|
|
}
|
|
}
|
|
|
|
|
|
// [x] Then do the same check except for each c.alias
|
|
|
|
for inalias in &incmd.alias {
|
|
|
|
if inalias.to_lowercase() == dbcmd.command.to_lowercase() {
|
|
// Returning State - with the identified module
|
|
// return Some((module.clone(),BotAction::C(dbcmd)));
|
|
return Some(module.clone()); // works
|
|
|
|
}
|
|
|
|
for a in &dbcmd.alias {
|
|
if inalias.to_lowercase() == a.to_lowercase() {
|
|
// Returning State - with the identified module
|
|
// return Some((module.clone(),BotAction::C(dbcmd)));
|
|
return Some(module.clone()); // works
|
|
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
// return Some(BotModule(String::from("GambaCore")))
|
|
}
|
|
|
|
|
|
// for all other scenarios (e.g., Listener, Routine), find no conflicts
|
|
None
|
|
|
|
}
|
|
|
|
// if let probmod = find_conflict_module(&self, &in_action) {
|
|
// // () // return because there was a conflict?
|
|
// panic!("ERROR: Could not add {:?} ; there was a conflict with existing module {:?}", in_action , probmod );
|
|
// }
|
|
match find_conflict_module(&self, &in_action) {
|
|
// Some(c) => panic!("ERROR: Could not add {:?} ; there was a conflict with existing module {:?}", in_action , c ),
|
|
Some(c) => panic!("ERROR: Could not add module; there was a conflict with existing module {:?}", c ),
|
|
None => (),
|
|
}
|
|
|
|
let statusvector = self.statusdb
|
|
// .entry(BotModule(String::from("experiments")))
|
|
.entry(in_module.clone())
|
|
.or_insert(Vec::new());
|
|
|
|
statusvector.push(ModStatusType::Enabled(StatusLvl::Instance)); // Pushes the Module as Enabled at Instance Level
|
|
|
|
let modactions = self.botactions
|
|
//.entry( BotModule(String::from("experiments")))
|
|
.entry( in_module.clone())
|
|
.or_insert(Vec::new());
|
|
|
|
// modactions.push(BotAction::L(newlistener));
|
|
modactions.push(in_action);
|
|
|
|
println!(">> Modules Manager : Called Add bot Action");
|
|
//println!(">> Modules Manager : {:?}",&self);
|
|
|
|
//();
|
|
//let mgr = self;
|
|
|
|
//mgr
|
|
|
|
//self
|
|
}
|
|
|
|
|
|
|
|
|
|
fn statuscleanup(&self,_:Option<ChType>) -> () {
|
|
// internal cleans up statusdb . For example :
|
|
// - remove redudancies . If we see several Enabled("m"), only keep 1x
|
|
// - Clarify Conflict. If we see Enabled("m") and Disabled("m") , we remove Enabled("m") and keep Disabled("m")
|
|
// the IDEAL is that this is ran before every read/update operation to ensure quality
|
|
// Option<ChType> can pass Some(Channel("m")) (as an example) so statuscleanup only works on the given channel
|
|
// Passing None to chnl may be a heavy operation, as this will review and look at the whole table
|
|
()
|
|
}
|
|
|
|
|
|
|
|
} |