832 lines
33 KiB
Rust
832 lines
33 KiB
Rust
|
|
use std::borrow::Borrow;
|
|
use std::collections::HashMap;
|
|
use std::error::Error;
|
|
|
|
use crate::core::botmodules::{ModulesManager,Listener,BotModule,BotActionTrait, BotCommand};
|
|
use crate::core::botmodules::bot_actions::actions_util;
|
|
|
|
use crate::core::botinstance::{self,BotInstance};
|
|
use futures::lock::Mutex;
|
|
use twitch_irc::message::{Badge, PrivmsgMessage};
|
|
|
|
use crate::core::botmodules::ChType;
|
|
|
|
use crate::core::botinstance::ArcBox;
|
|
|
|
|
|
use std::rc::Rc;
|
|
use std::cell::RefCell;
|
|
|
|
use std::sync::{Arc, RwLock};
|
|
|
|
fn adminvector() -> Vec<String> {
|
|
vec![String::from("ModulatingForce")]
|
|
}
|
|
|
|
|
|
// pub fn init(mgr:&mut ModulesManager)
|
|
pub fn init(mgr:Arc<Mutex<ModulesManager>>)
|
|
{
|
|
|
|
BotCommand {
|
|
module : BotModule(String::from("identity")),
|
|
command : String::from("promote"), // command call name
|
|
alias : vec![], // String of alternative names
|
|
exec_body : actions_util::asyncbox(cmd_promote) ,
|
|
help : String::from("promote"),
|
|
required_roles : vec![
|
|
UserRole::Mod(ChType::Channel(String::new())),
|
|
UserRole::SupMod(ChType::Channel(String::new())),
|
|
UserRole::Broadcaster,
|
|
UserRole::BotAdmin,
|
|
],
|
|
}.add_to_modmgr(mgr);
|
|
|
|
async fn cmd_promote(mut bot:Arc<Mutex<BotInstance>>,msg:PrivmsgMessage)
|
|
{
|
|
//println!("(#{}) {}: {}", msg.channel_login, msg.sender.name, msg.message_text);
|
|
println!("Called cmd promote");
|
|
|
|
// -- If the BotCommand.command was called (e.g., promote) & required roles were validated OUTSIDE of this call
|
|
// , this is the current function body to execute
|
|
|
|
/*
|
|
- `promote` / `demote`
|
|
- [ ] `SupMod` & `Broadcaster` & `BotAdmin` can run
|
|
- [ ] `UserRole`s that can run, can
|
|
- [ ] run `promote` on a regular `Chatter` to make them a `Mod`
|
|
- [ ] run `demote` on a `Mod` to make them a `Chatter`
|
|
- [ ] Only `BotAdmin` can :
|
|
- [ ] target themselves to `promote` / `demote` , in the case that they want to make themselves either a `Mod` or `SupMod` for the channel temporarily
|
|
- [ ] `promote admin <Chatter>` to assign them `BotAdmin` role
|
|
- `[ ] Broadcaster` & `BotAdmin` can `demote` a `SupMod` to make them a `Mod`
|
|
*/
|
|
|
|
|
|
/*
|
|
Usage :
|
|
|
|
promote <user> <channel>
|
|
|
|
demote <user> <channel>
|
|
|
|
promote admin <user>
|
|
|
|
*/
|
|
|
|
//let bot = Rcbot;
|
|
|
|
println!("{}",msg.message_text);
|
|
let mut argv = msg.message_text.split(" ");
|
|
|
|
argv.next(); // Skip the command name
|
|
|
|
let arg1 = argv.next();
|
|
|
|
let arg2 = argv.next();
|
|
|
|
let mut sender_badge:Option<ChatBadge> = None;
|
|
|
|
for b in &msg.badges {
|
|
if b.name == "moderator" {
|
|
sender_badge = Some(ChatBadge::Mod);
|
|
} else if b.name == "broadcaster" {
|
|
sender_badge = Some(ChatBadge::Broadcaster);
|
|
}
|
|
}
|
|
|
|
|
|
match arg1 {
|
|
Some(a1) if a1 == String::from("admin") => {
|
|
// - BotAdmins can promote admin to give BotAdmin UserRole
|
|
//let mut bot = Rc::clone(&bot);
|
|
// let a = bot.botmgrs.identity.getspecialuserroles(msg.sender.name.to_lowercase(), Some(ChType::Channel(msg.channel_login.to_lowercase())));
|
|
// let a = Rc::try_unwrap(bot).ok().unwrap().into_inner().botmgrs.identity.getspecialuserroles(msg.sender.name.to_lowercase(), Some(ChType::Channel(msg.channel_login.to_lowercase())));
|
|
// let a = Rc::try_unwrap(bot.clone()).ok().unwrap().into_inner().botmgrs.identity.getspecialuserroles(msg.sender.name.to_lowercase(), Some(ChType::Channel(msg.channel_login.to_lowercase())));
|
|
|
|
// let a = Rc::try_unwrap(bot).ok().unwrap()
|
|
// // .borrow_mut()
|
|
// .into_inner()
|
|
// .botmgrs
|
|
// .identity
|
|
// .getspecialuserroles(msg.sender.name.to_lowercase(),
|
|
// Some(ChType::Channel(msg.channel_login.to_lowercase())));
|
|
// let p = Rc::try_unwrap(bot.clone())
|
|
// let p = Arc::try_unwrap(bot.clone())
|
|
// .ok()
|
|
// .unwrap()
|
|
// //.into_inner()
|
|
// //.to_owned()
|
|
// // .get_mut()
|
|
// .into_inner();
|
|
// // .ok()
|
|
// // .unwrap();
|
|
// // let p = p.ok().unwrap();
|
|
|
|
// let p = bot.lock().await.get_identity();
|
|
// let p = p.lock().await;
|
|
// let ta = p.getspecialuserroles(String::from("Hello"), Some(ChType::Channel(msg.channel_login.to_lowercase()))).await;
|
|
// // let ta = *ta.await;
|
|
// let ta = *ta.lock().await;
|
|
|
|
// if let Some(a) = ta {
|
|
|
|
|
|
let p = bot.lock().await.get_identity();
|
|
let mut p = p.lock().await;
|
|
let ta = p.getspecialuserroles(String::from("Hello"), Some(ChType::Channel(msg.channel_login.to_lowercase()))).await;
|
|
|
|
if let Some(a) = ta {
|
|
|
|
if a.contains(&UserRole::BotAdmin) {
|
|
println!("BotAdmin allowed to promote admin");
|
|
// let bota = Rc::clone(&bot);
|
|
// let bota = Rc::get_mut(&bota);
|
|
// match bota.botmgrs.identity.promote(msg.sender.name.to_lowercase(), None, Some(UserRole::BotAdmin)) {
|
|
//let mut bot = Rc::clone(&bot);
|
|
// let bot = Rc::<&botinstance::BotInstance>::get_mut(&mut bot);
|
|
// let mut bot = Rc::make_mut(&mut bot);
|
|
// let mut bot = Rc::make_mut(&bot);
|
|
// match Rc::<&botinstance::BotInstance>::get_mut(bot) {
|
|
// Some(bot) => {
|
|
// match bot.botmgrs.identity.promote(msg.sender.name.to_lowercase(), None, Some(UserRole::BotAdmin)) {
|
|
// // Success(_) => {
|
|
// // ;
|
|
// // },
|
|
// ChangeResult::Success(a) => println!("Succesfully promoted : {a} ;"),
|
|
// ChangeResult::Failed(a) => println!("Failed to promote : {a} ; "),
|
|
// ChangeResult::NoChange(a) => println!("No Changes Made : {a} ; "),
|
|
|
|
// }
|
|
// },
|
|
// None => (),
|
|
// }
|
|
//let bot = Rc::<botinstance::BotInstance>::make_mut(bot);
|
|
// match Rc::<IdentityManager>::make_mut(&mut Rc::new(bot.botmgrs.identity)).promote(msg.sender.name.to_lowercase(), None, Some(UserRole::BotAdmin)) {
|
|
// match Rc::try_unwrap(bot.clone()).ok().unwrap().into_inner().botmgrs.identity.promote(msg.sender.name.to_lowercase(), None, Some(UserRole::BotAdmin)) {
|
|
// match Arc::try_unwrap(bot.clone()).ok().unwrap().into_inner().ok().unwrap().botmgrs.identity.promote(msg.sender.name.to_lowercase(), None, Some(UserRole::BotAdmin)) {
|
|
// match Arc::try_unwrap(bot.clone()).ok().unwrap().into_inner().botmgrs.identity.promote(msg.sender.name.to_lowercase(), None, Some(UserRole::BotAdmin)) {
|
|
// match bot.read().ok().unwrap().get_identity().promote(msg.sender.name.to_lowercase(), None, Some(UserRole::BotAdmin)) {
|
|
// let a = bot.get_mut();
|
|
// match a.get_identity().promote(msg.sender.name.to_lowercase(), None, Some(UserRole::BotAdmin)) {
|
|
// let a = (*bot).clone();
|
|
{
|
|
// let a = bot.lock().await.get_botmgrs().clone();
|
|
// let a = bot.lock().await;
|
|
// let mut mutex = Arc::clone(&bot);
|
|
// match mutex.get_mut().get_identity().promote(msg.sender.name.to_lowercase(), None, Some(UserRole::BotAdmin)) {
|
|
// slet ee = ArcBox(bot);
|
|
// println!("tester: {:?}",(*bot).lock().await.get_prefix());
|
|
// let mutex = Arc::clone(&bot);
|
|
// let mut mutex2 = Arc::new(*mutex).into_inner().get_identity();
|
|
// let mut mutex2 = Arc::clone(&mutex).into_inner().get_identity();
|
|
// let a = (*bot).lock().await.get_identity();
|
|
// let mut a = a.lock().await;
|
|
let p = bot.lock().await.get_identity();
|
|
let mut p = p.lock().await;
|
|
let ta = p.promote(msg.sender.name.to_lowercase(), None, Some(UserRole::BotAdmin)).await;
|
|
|
|
match ta {
|
|
// Success(_) => {
|
|
// ;
|
|
// },
|
|
ChangeResult::Success(a) => println!("Succesfully promoted : {a} ;"),
|
|
ChangeResult::Failed(a) => println!("Failed to promote : {a} ; "),
|
|
ChangeResult::NoChange(a) => println!("No Changes Made : {a} ; "),
|
|
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
},
|
|
Some(_) => {
|
|
// -
|
|
|
|
},
|
|
_ => (),
|
|
}
|
|
|
|
|
|
|
|
// match String::from(arg1) {
|
|
// a if a == String::from("admin") => (),
|
|
// _ => (),
|
|
// }
|
|
|
|
|
|
// match argv[1] {
|
|
// String::from("admin") => (),
|
|
|
|
// }
|
|
|
|
let arg2 = argv.next();
|
|
|
|
let targetchnl = arg2;
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
}
|
|
|
|
BotCommand {
|
|
module : BotModule(String::from("identity")),
|
|
command : String::from("demote"), // command call name
|
|
alias : vec![], // String of alternative names
|
|
exec_body : actions_util::asyncbox(cmd_demote) ,
|
|
help : String::from("demote"),
|
|
required_roles : vec![
|
|
UserRole::Mod(ChType::Channel(String::new())),
|
|
UserRole::SupMod(ChType::Channel(String::new())),
|
|
UserRole::Broadcaster,
|
|
UserRole::BotAdmin,
|
|
],
|
|
}.add_to_modmgr(mgr);
|
|
|
|
|
|
async fn cmd_demote(mut _chat:Arc<Mutex<BotInstance>>,_msg:PrivmsgMessage) {
|
|
println!("Called cmd demote");
|
|
}
|
|
|
|
|
|
|
|
BotCommand {
|
|
module : BotModule(String::from("identity")),
|
|
command : String::from("getroles"), // command call name
|
|
alias : vec![], // String of alternative names
|
|
exec_body : actions_util::asyncbox(getroles) ,
|
|
help : String::from("getroles"),
|
|
required_roles : vec![
|
|
UserRole::Mod(ChType::Channel(String::new())),
|
|
UserRole::SupMod(ChType::Channel(String::new())),
|
|
UserRole::Broadcaster,
|
|
UserRole::BotAdmin,
|
|
],
|
|
}.add_to_modmgr(mgr);
|
|
|
|
|
|
async fn getroles(bot:Arc<Mutex<BotInstance>>,msg:PrivmsgMessage) {
|
|
println!("Called cmd getroles");
|
|
|
|
/*
|
|
Usage
|
|
|
|
getroles <user> <Channel>
|
|
- If channel is provided, provide roles for that channel specifically
|
|
|
|
*/
|
|
|
|
// IN other code areas , I see this
|
|
// ServerMessage::Privmsg(msg) => {
|
|
// println!("(#{}) {}: {}", msg.channel_login, msg.sender.name, msg.message_text);
|
|
|
|
// println!("{}",msg.message_text);
|
|
let mut argv = msg.message_text.split(" ");
|
|
|
|
// for v in argv {
|
|
// println!("args : {v}");
|
|
// }
|
|
|
|
|
|
argv.next(); // Skip the command name
|
|
|
|
let arg1 = argv.next();
|
|
|
|
// if arg == None {
|
|
// return ; // Do nothing if no arguments
|
|
// }
|
|
|
|
|
|
let targetuser = match arg1 {
|
|
None => return , // exit if no arguments
|
|
Some(arg) => arg,
|
|
};
|
|
|
|
// match String::from(arg1) {
|
|
// a if a == String::from("admin") => (),
|
|
// _ => (),
|
|
// }
|
|
|
|
|
|
// match argv[1] {
|
|
// String::from("admin") => (),
|
|
|
|
// }
|
|
|
|
let arg2 = argv.next();
|
|
|
|
let targetchnl = arg2;
|
|
|
|
// // let a = bot.read().ok().unwrap().get_identity();
|
|
// let a = bot.lock().await;
|
|
// // let a = a.lock().await;
|
|
// // let a = a.get_identity().await;
|
|
// let a = a.botmgrs;
|
|
// // let a = *(*a).lock().await;
|
|
// let a = *a.lock().await;
|
|
// let a = a.identity;
|
|
// let a = *a.lock().await;
|
|
|
|
// let a = bot.clone();
|
|
// let a = a.into_inner();
|
|
// let a = a.botmgrs;
|
|
// let a = a.into_inner();
|
|
// let a = a.identity;
|
|
// let a = a.into_inner();
|
|
let a = bot.clone();
|
|
let a = a.lock().await;
|
|
let a = a.get_identity().await;
|
|
// let a = a.lock().await;
|
|
let sproles = match targetchnl {
|
|
None => {
|
|
// let bot = Rc::clone(&bot);
|
|
//let bot = Arc::clone(&bot);
|
|
// let a = bot.botmgrs.identity.getspecialuserroles(String::from(targetuser),None);
|
|
// let a = Arc::try_unwrap(bot).ok().unwrap().into_inner().ok().unwrap();
|
|
// let a = Arc::try_unwrap(bot.clone()).ok().unwrap().into_inner();
|
|
// let a = a.botmgrs.identity.getspecialuserroles(String::from(targetuser),None);
|
|
// let a = a.ok().getspecialuserroles(String::from(targetuser),None);
|
|
// let a = bot.read().ok().unwrap().rIdentity().getspecialuserroles(String::from(targetuser),None);
|
|
// println!("Retrieved User Roles >> {:?}",a);
|
|
a.lock().await.getspecialuserroles(String::from(targetuser),None).await
|
|
},
|
|
Some(targetchnl) => {
|
|
// let bot = Rc::clone(&bot);
|
|
// let bot = Arc::clone(&bot);
|
|
// let a = bot.botmgrs.identity.getspecialuserroles(String::from(targetuser), Some(ChType::Channel(String::from(targetchnl))));
|
|
// Arc::try_unwrap(boxed_bot.clone()).ok().unwrap().into_inner()
|
|
// let a = Arc::try_unwrap(bot).ok().unwrap().into_inner().ok().unwrap();
|
|
// let a = Arc::try_unwrap(bot.clone()).ok().unwrap().into_inner();
|
|
// let a = a.botmgrs.identity.getspecialuserroles(String::from(targetuser), Some(ChType::Channel(String::from(targetchnl))));
|
|
// let a = bot.read().ok().unwrap().rIdentity().getspecialuserroles(String::from(targetuser),None);
|
|
// println!("Retrieved User Roles >> {:?}",a);
|
|
// bot.read().ok().unwrap().rIdentity().getspecialuserroles(String::from(targetuser),None)
|
|
a.lock().await.getspecialuserroles(String::from(targetuser),None).await
|
|
|
|
},
|
|
};
|
|
|
|
|
|
println!("Retrieved User Roles >> {:?}",sproles);
|
|
|
|
// let a = bot.identity.getuserroles(String::from("ModulatingForce"), Some(ChType::Channel(String::from("ModulatingForcebot"))));
|
|
// println!("{:?}",a);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
// #[derive(Debug, PartialEq, Eq, Hash, Clone)]
|
|
// pub enum ChType {
|
|
// Channel(String),
|
|
// }
|
|
|
|
#[derive(Debug, PartialEq, Eq , Clone)]
|
|
pub enum UserRole {
|
|
Chatter,
|
|
Mod(ChType), // String specifies Channel
|
|
SupMod(ChType), // String specifies Channel
|
|
Broadcaster,
|
|
BotAdmin,
|
|
|
|
}
|
|
|
|
|
|
pub enum Permissible {
|
|
Allow,
|
|
Block
|
|
}
|
|
|
|
#[derive(Clone)]
|
|
pub struct IdentityManager {
|
|
// special_roles_users : HashMap<String,Vec<UserRole>>, // # <-- (!) This must be String instead of ChType because we're checking a User not a Channel
|
|
special_roles_users : Arc<Mutex<HashMap<String,Vec<UserRole>>>>, // # <-- (!) This must be String instead of ChType because we're checking a User not a Channel
|
|
// parent_mgr : Box<crate::core::botinstance::BotManagers>,
|
|
//parent_mgr : Option<Box<crate::core::botinstance::BotManagers>>,
|
|
}
|
|
|
|
pub enum ChatBadge {
|
|
Broadcaster,
|
|
Mod,
|
|
}
|
|
|
|
|
|
enum ChangeResult {
|
|
Success(String),
|
|
Failed(String),
|
|
NoChange(String),
|
|
}
|
|
|
|
|
|
impl IdentityManager {
|
|
|
|
pub fn init() -> IdentityManager {
|
|
let mut a = HashMap::new();
|
|
for admn in adminvector() {
|
|
a.insert(admn.to_lowercase(),vec![UserRole::BotAdmin]);
|
|
};
|
|
|
|
IdentityManager {
|
|
special_roles_users : Arc::new(Mutex::new(a)),
|
|
//parent_mgr : None,
|
|
}
|
|
}
|
|
|
|
// [ ] Maybe I should create a can_user_run version that simply takes PrvMsg, but then calls can_user_run directly
|
|
|
|
// pub fn can_user_run_PRVMSG(self,msg:&PrivmsgMessage,cmdreqroles:Vec<UserRole>) -> Result<Permissible,Box<dyn Error>>
|
|
// pub fn can_user_run_PRVMSG(&self,msg:&PrivmsgMessage,cmdreqroles:Vec<UserRole>) -> Permissible
|
|
pub async fn can_user_run_PRVMSG(self,msg:&PrivmsgMessage,cmdreqroles:Vec<UserRole>) -> Permissible
|
|
{
|
|
// println!("(#{}) {}: {}", msg.channel_login, msg.sender.name, msg.message_text);
|
|
|
|
// [ ] Check what Badges in PrivmsgMessage
|
|
|
|
let mut sender_badge:Option<ChatBadge> = None;
|
|
|
|
for b in &msg.badges {
|
|
if b.name == "moderator" {
|
|
sender_badge = Some(ChatBadge::Mod);
|
|
} else if b.name == "broadcaster" {
|
|
sender_badge = Some(ChatBadge::Broadcaster);
|
|
}
|
|
}
|
|
|
|
// if &msg.badges.contains(Badge{}) {
|
|
|
|
// }
|
|
|
|
if let Some(sender_badge) = sender_badge {
|
|
// return &self.can_user_run(msg.sender.name.to_owned(),
|
|
// ChType::Channel(msg.channel_login.to_owned()),
|
|
// sender_badge,
|
|
// cmdreqroles
|
|
// return self.can_user_run(msg.sender.name.to_owned(),
|
|
// let a = Arc::new(Mutex::new(self));
|
|
// let mut a = a.lock().await;
|
|
// let a = **a;
|
|
// let a = a.can_user_run(msg.sender.name.to_owned(),
|
|
// ChType::Channel(msg.channel_login.to_owned()),
|
|
// sender_badge,
|
|
// cmdreqroles
|
|
// ) ;
|
|
// let a = *self;
|
|
// let a = Arc::new(Mutex::new(a));
|
|
// let a = a.lock().await.can_user_run(msg.sender.name.to_owned(),
|
|
// ChType::Channel(msg.channel_login.to_owned()),
|
|
// sender_badge,
|
|
// cmdreqroles
|
|
// ) ;
|
|
// return a;
|
|
self.can_user_run(msg.sender.name.to_owned(),
|
|
ChType::Channel(msg.channel_login.to_owned()),
|
|
sender_badge,
|
|
cmdreqroles
|
|
) ;
|
|
}
|
|
|
|
|
|
|
|
// [ ] Call can_user_run()
|
|
Permissible::Block
|
|
}
|
|
|
|
pub async fn can_user_run(&self,
|
|
usr:String,
|
|
channelname:ChType,
|
|
chat_badge:ChatBadge,
|
|
cmdreqroles:Vec<UserRole>
|
|
// ) -> Result<Permissible,Box<dyn Error>> {
|
|
) -> Permissible {
|
|
/*
|
|
canUserRun -
|
|
|
|
Input :
|
|
usr:String,
|
|
channelname:ChType,
|
|
chat_badge:ChatBadge,
|
|
cmdreqroles:Vec<UserRole>
|
|
|
|
Output : Result<Permissible,Box<dyn Error>>
|
|
Some Possible outcomes : Ok(Permissible::Allow) , Ok(Permissible::Block)
|
|
|
|
|
|
Description
|
|
For a Given Chatter (with any special ChatBadge) who ran the Command at a Given Channel , check if that user can
|
|
run the command based on the given cmdreqroles required by the command
|
|
|
|
Inputs and business logic determine if the user can run the command based on the command's required roles
|
|
*/
|
|
|
|
|
|
// Requirements
|
|
/*
|
|
[x] If cmdreqroles is empty vector , automatically assume Ok(Permissible::Allow)
|
|
[x] If chatBadge::Broadcaster ...
|
|
[x] and cmdreqroles includes UserRole::Broadcaster , Ok(Permissible::Allow)
|
|
[x] and cmdreqroles includes UserRole::Mod("") OR UserRole::SupMod("") , Ok(Permissible::Allow)
|
|
[x] If chatBadge::Mod ...
|
|
[x] Check if they have either UserRole::Mod(channelname::ChType) or UserRole::SupMod(channelname::ChType)
|
|
[x] If not, assign them UserRole::Mod(channelname::ChType)
|
|
[x] If cmdreqroles includes UserRole::Mod("") , checks if chatter has UserRole::Mod(channelname::ChType) or UserRole::SupMod(channelname::ChType) to determine if Ok(Permissible::Allow)
|
|
[x] If cmdreqroles includes UserRole::SupMod("") , checks if chatter has UserRole::SupMod(channelname::ChType) to determine if Ok(Permissible::Allow)
|
|
[x] If cmdreqroles includes UserRole::BotAdmin and chatter has UserRole::BotAdmin , Ok(Permissible::Allow)
|
|
[x] Otherwise, Ok(Permissible::Block)
|
|
*/
|
|
|
|
// [x] If cmdreqroles is empty vector , automatically assume Ok(Permissible::Allow)
|
|
|
|
if cmdreqroles.len() == 0 {
|
|
// return Ok(Permissible::Allow)
|
|
return Permissible::Allow
|
|
}
|
|
|
|
|
|
|
|
match chat_badge {
|
|
|
|
// [x] If chatBadge::Broadcaster ...
|
|
// [x] and cmdreqroles includes UserRole::Broadcaster , Ok(Permissible::Allow)
|
|
// [x] and cmdreqroles includes UserRole::Mod("") OR UserRole::SupMod("") , Ok(Permissible::Allow)
|
|
|
|
ChatBadge::Broadcaster => {
|
|
if cmdreqroles.contains(&UserRole::Broadcaster) ||
|
|
cmdreqroles.contains(&UserRole::Mod(ChType::Channel(String::new()))) ||
|
|
cmdreqroles.contains(&UserRole::SupMod(ChType::Channel(String::new()))) {
|
|
// return Ok(Permissible::Allow)
|
|
return Permissible::Allow
|
|
}
|
|
},
|
|
|
|
// [x] If chatBadge::Mod ...
|
|
// [x] Check if they have either UserRole::Mod(channelname::ChType) or UserRole::SupMod(channelname::ChType)
|
|
// [x] If not, assign them UserRole::Mod(channelname::ChType)
|
|
|
|
ChatBadge::Mod => {
|
|
|
|
// println!("Mod Chatbadge detected");
|
|
|
|
// println!("debug special roles : {:?}",self.special_roles_users);
|
|
// println!("debug usr : {}",&usr.to_lowercase());
|
|
|
|
// let Some((k,v)) = self.special_roles_users.get_key_value(usr);
|
|
// match self.special_roles_users.get_mut(&usr.to_lowercase()) {
|
|
// match self.special_roles_users.get(&usr.to_lowercase()) {
|
|
match self.special_roles_users.lock().await.get(&usr.to_lowercase()) {
|
|
Some(usrroles) => {
|
|
// println!("contains mod : {}", usrroles.contains(&UserRole::Mod(channelname.clone())));
|
|
// println!("contains supmod : {}", usrroles.contains(&UserRole::SupMod(channelname.clone())));
|
|
if usrroles.contains(&UserRole::Mod(channelname.clone())) ||
|
|
usrroles.contains(&UserRole::SupMod(channelname.clone())) {
|
|
// Do nothing - this is expected
|
|
} else {
|
|
// in this case, they have a ChatBadge::Mod but should have this for the channel
|
|
// let mut a = usrroles;
|
|
// usrroles.push(UserRole::Mod(channelname.clone()));
|
|
// a.push(UserRole::Mod(channelname.clone()));
|
|
self.special_roles_users
|
|
.lock().await
|
|
.get_mut(&usr.to_lowercase())
|
|
.expect("ERROR")
|
|
.push(UserRole::Mod(channelname.clone()));
|
|
// println!("debug special roles : {:?}",self.special_roles_users);
|
|
}
|
|
},
|
|
_ => ()
|
|
}
|
|
|
|
},
|
|
// _ => (),
|
|
}
|
|
|
|
// [x] If cmdreqroles includes UserRole::Mod("") , checks if chatter has UserRole::Mod(channelname::ChType) or UserRole::SupMod(channelname::ChType) to determine if Ok(Permissible::Allow)
|
|
|
|
println!("cmd required roles : {:?}",cmdreqroles);
|
|
|
|
if cmdreqroles.contains(&UserRole::Mod(ChType::Channel(String::new()))) {
|
|
// match self.special_roles_users.get(&channelname) {
|
|
// Some(usrroles) => {},
|
|
// None => (),
|
|
|
|
// }
|
|
|
|
println!("Mod Role required");
|
|
|
|
if let Some(a) = self.special_roles_users.lock().await.get(&usr.to_lowercase()) {
|
|
if a.contains(&UserRole::Mod(channelname.clone())) || a.contains(&UserRole::SupMod(channelname.clone())){
|
|
// return Ok(Permissible::Allow);
|
|
return Permissible::Allow
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
// [x] If cmdreqroles includes UserRole::SupMod("") , checks if chatter has UserRole::SupMod(channelname::ChType) to determine if Ok(Permissible::Allow)
|
|
|
|
|
|
if cmdreqroles.contains(&UserRole::SupMod(ChType::Channel(String::new()))) {
|
|
if let Some(a) = self.special_roles_users.lock().await.get(&usr.to_lowercase()) {
|
|
if a.contains(&UserRole::SupMod(channelname.clone())) {
|
|
// return Ok(Permissible::Allow);
|
|
return Permissible::Allow
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
// [x] If cmdreqroles includes UserRole::BotAdmin and chatter has UserRole::BotAdmin , Ok(Permissible::Allow)
|
|
|
|
println!("Eval cmdreqroles with botadmin : {}",cmdreqroles.contains(&UserRole::BotAdmin));
|
|
|
|
if cmdreqroles.contains(&UserRole::BotAdmin) {
|
|
println!("special roles get : {:?}",self.special_roles_users.lock().await.get(&usr.to_lowercase()));
|
|
if let Some(a) = self.special_roles_users.lock().await.get(&usr.to_lowercase()) {
|
|
println!("special roles contains BotAdmin: {}",a.contains(&UserRole::BotAdmin));
|
|
if a.contains(&UserRole::BotAdmin) {
|
|
// return Ok(Permissible::Allow);
|
|
return Permissible::Allow
|
|
}
|
|
}
|
|
}
|
|
|
|
Permissible::Block
|
|
}
|
|
|
|
pub async fn promote(&mut self,trgchatter:String,channel:Option<ChType>,trg_role:Option<UserRole>) -> ChangeResult {
|
|
|
|
// Note : If channel is none, getspecialuserroles() returns all roles for the user
|
|
|
|
// let chatterroles = self.getspecialuserroles(trgchatter, channel);
|
|
|
|
// let chatterroles = self.getspecialuserroles(trgchatter.clone(), channel.clone());
|
|
// let chatterroles = *self.getspecialuserroles(trgchatter.clone(), channel.clone()).await;
|
|
// let chatterroles = chatterroles.lock().await;
|
|
// // let chatterroles = *chatterroles;
|
|
// let chatterroles = chatterroles.unwrap();
|
|
|
|
|
|
let chatterroles = self.getspecialuserroles(trgchatter.clone(), channel.clone()).await;
|
|
// let chatterroles = chatterroles.lock().await;
|
|
// let chatterroles = *chatterroles;
|
|
let chatterroles = chatterroles.unwrap();
|
|
|
|
|
|
// let emptyvec = vec![];
|
|
|
|
// let chatterroles = match chatterroles {
|
|
// Some(a) => a,
|
|
// _ => &(emptyvec),
|
|
// };
|
|
|
|
|
|
match trg_role {
|
|
Some(UserRole::Mod(a)) => {
|
|
if let Some(trg_chnl) = channel {
|
|
if chatterroles.contains(&UserRole::Mod(trg_chnl.clone())) {
|
|
return ChangeResult::NoChange(String::from("Target User already has Target Role"));
|
|
}
|
|
// # otherwise, trg_role for the given chnl is not assigned to the trgchatter
|
|
// chatterroles.push(UserRole::Mod(trg_chnl.clone()));
|
|
self.special_roles_users
|
|
.lock().await
|
|
.get_mut(&trgchatter)
|
|
.expect("Error getting roles")
|
|
.push(UserRole::Mod(trg_chnl));
|
|
|
|
return ChangeResult::Success(String::from("Promotion Successful"));
|
|
}
|
|
|
|
|
|
},
|
|
Some(UserRole::SupMod(a)) => (),
|
|
Some(UserRole::BotAdmin) => (),
|
|
Some(_) => (),
|
|
None => (),
|
|
}
|
|
|
|
|
|
// match chatterroles {
|
|
// Some(chatterroles) => {
|
|
|
|
// // [x] chatter already has the target role
|
|
// if chatterroles.contains(&trg_role) {
|
|
// return ChangeResult::NoChange(String::from("Target User already has Target Role"));
|
|
// }
|
|
|
|
// // By this point, chatteroles does not contain target role
|
|
// // match trgRole {
|
|
// // Some(trgRole) => {
|
|
// // match trgRole {
|
|
// // UserRole::Mod(a) => {
|
|
|
|
// // },
|
|
// // UserRole::SupMod(a) => (),
|
|
// // UserRole::BotAdmin => (),
|
|
// // _ => (), // <-- do nothing with al other options
|
|
// // }
|
|
// // },
|
|
// // None => {
|
|
// // /*
|
|
// // - If trgRole is None , then promote by implicit rules . For example,
|
|
// // - For UserRoles without Mod or SupMod & Caller is SupMod | Broadcaster | BotAdmin > To Mod
|
|
// // - For Mod & Caller is SupMod | Broadcaster | BotAdmin > To SupMod
|
|
// // - For UserRoles without BotAdmin & Caller is BotAdmin > To BotAdmin
|
|
// // */
|
|
// // },
|
|
|
|
// // }
|
|
|
|
// // let trgRole = match trgRole {
|
|
// // Some(UserRole::Mod(a)) => a,
|
|
// // Some(UserRole::SupMod(a)) => a,
|
|
// // Some(UserRole::BotAdmin) => UserRole::BotAdmin,
|
|
// // None => {
|
|
// // /*
|
|
// // - If trgRole is None , then promote by implicit rules . For example,
|
|
// // - For UserRoles without Mod or SupMod & Caller is SupMod | Broadcaster | BotAdmin > To Mod
|
|
// // - For Mod & Caller is SupMod | Broadcaster | BotAdmin > To SupMod
|
|
// // - For UserRoles without BotAdmin & Caller is BotAdmin > To BotAdmin
|
|
// // */
|
|
// // },
|
|
|
|
// // };
|
|
|
|
|
|
|
|
// // if let Some(trgRole) = trgRole {
|
|
|
|
// // // [x] chatter already has the target role
|
|
// // if chatterroles.contains(&trgRole) {
|
|
// // return ChangeResult::NoChange(String::from("Target User already has Target Role"));
|
|
// // }
|
|
|
|
// // // [ ] trgRole should be assigned based on the input channel
|
|
// // let roletoassign = UserRole::
|
|
// // }
|
|
|
|
// },
|
|
// _ => (),
|
|
// }
|
|
|
|
ChangeResult::Success(String::from("TEST > Promotion Successful"))
|
|
}
|
|
|
|
pub fn demote(self,trgchatter:String,channel:Option<ChType>,trgRole:Option<UserRole>) -> ChangeResult {
|
|
|
|
ChangeResult::Success(String::from("TEST > Promotion Successful"))
|
|
}
|
|
|
|
pub async fn getspecialuserroles(&self,chattername:String,channel:Option<ChType>) -> Option<Vec<UserRole>> {
|
|
|
|
// let a = chattername.to_lowercase();
|
|
|
|
// self.special_roles_users.get(&a)
|
|
|
|
|
|
|
|
// for k in self.special_roles_users.keys() {
|
|
// println!("Special Roles Keys {k}");
|
|
// for v in
|
|
// }
|
|
|
|
// for (k,v) in &self.special_roles_users {
|
|
// println!("User {k}");
|
|
// println!("> Roles : {:?}",v);
|
|
// }
|
|
|
|
let a = chattername.to_lowercase();
|
|
|
|
// println!("{a}");
|
|
|
|
// let b = self.special_roles_users.lock().await.get(&a);
|
|
// match b
|
|
// {
|
|
// Some(b) => Some(*b),
|
|
// None => None,
|
|
// }
|
|
|
|
let b = self.special_roles_users.lock().await.remove(&a);
|
|
let outp = b;
|
|
// let b = Arc::new(Mutex::new(outp));
|
|
outp
|
|
|
|
|
|
// let b = Arc::new(Mutex::new(b));
|
|
// b
|
|
|
|
|
|
|
|
// Some(vec![UserRole::Mod(ChType::Channel(String::from("modulatingforcebot")))])
|
|
}
|
|
|
|
|
|
}
|