316 lines
12 KiB
Rust
316 lines
12 KiB
Rust
|
|
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};
|
|
use twitch_irc::message::{Badge, PrivmsgMessage};
|
|
|
|
use crate::core::botmodules::ChType;
|
|
|
|
fn adminvector() -> Vec<String> {
|
|
vec![String::from("ModulatingForce")]
|
|
}
|
|
|
|
|
|
pub fn init(mgr:&mut 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 _chat:botinstance::Chat,_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), 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`
|
|
*/
|
|
|
|
|
|
// [ ] Split message based on arguments
|
|
|
|
|
|
|
|
}
|
|
|
|
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:botinstance::Chat,_msg:PrivmsgMessage) {
|
|
println!("Called cmd demote");
|
|
}
|
|
|
|
|
|
}
|
|
|
|
|
|
// #[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
|
|
}
|
|
|
|
pub enum ChatBadge {
|
|
Broadcaster,
|
|
Mod,
|
|
}
|
|
|
|
|
|
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 : a,
|
|
}
|
|
}
|
|
|
|
// [ ] 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
|
|
{
|
|
// 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
|
|
) ;
|
|
}
|
|
|
|
|
|
|
|
// [ ] Call can_user_run()
|
|
Permissible::Block
|
|
}
|
|
|
|
pub fn can_user_run(mut 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()) {
|
|
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
|
|
usrroles.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.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.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.get(&usr.to_lowercase()));
|
|
if let Some(a) = self.special_roles_users.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
|
|
}
|
|
}
|