2024-03-01 23:36:37 -05:00
// use std::borrow::Borrow;
2024-01-29 06:18:27 -05:00
use std ::collections ::HashMap ;
2024-03-01 23:36:37 -05:00
// use std::error::Error;
2024-01-29 11:09:33 -05:00
use crate ::core ::botmodules ::bot_actions ::actions_util ;
2024-03-01 23:36:37 -05:00
// use crate::core::botmodules::{BotActionTrait, BotCommand, BotModule, Listener, ModulesManager};
use crate ::core ::botmodules ::{ BotActionTrait , BotCommand , BotModule , ModulesManager } ;
2024-01-29 11:09:33 -05:00
2024-03-01 23:36:37 -05:00
// use crate::core::botinstance::{self, botlog, BotInstance, ChType};
2024-03-02 10:06:26 -05:00
use crate ::core ::botinstance ::ChType ;
use crate ::core ::botlog ;
2024-03-01 23:36:37 -05:00
// use futures::lock::Mutex;
// use twitch_irc::message::{Badge, PrivmsgMessage};
use twitch_irc ::message ::PrivmsgMessage ;
2024-01-29 11:09:33 -05:00
2024-02-18 15:23:58 -05:00
// use crate::core::botmodules::ChType;
2024-01-29 12:41:26 -05:00
2024-03-01 23:36:37 -05:00
// use crate::core::botinstance::ArcBox;
2024-02-04 14:28:37 -05:00
2024-03-01 23:36:37 -05:00
// use std::cell::RefCell;
// use std::rc::Rc;
2024-02-04 14:28:37 -05:00
2024-02-19 21:04:01 -05:00
use std ::sync ::Arc ;
2024-02-12 05:25:38 -05:00
use tokio ::sync ::RwLock ;
2024-03-01 23:36:37 -05:00
use casual_logger ::Log ;
2024-02-04 14:28:37 -05:00
2024-02-12 01:25:12 -05:00
use super ::botmodules ::bot_actions ::actions_util ::BotAR ;
2024-01-29 06:18:27 -05:00
fn adminvector ( ) -> Vec < String > {
vec! [ String ::from ( " ModulatingForce " ) ]
2024-02-18 15:23:58 -05:00
//vec![]
2024-01-29 06:18:27 -05:00
}
2024-02-04 14:28:37 -05:00
// pub fn init(mgr:&mut ModulesManager)
2024-02-25 10:40:54 -05:00
pub async fn init ( mgr : Arc < ModulesManager > ) {
2024-02-13 10:11:49 -05:00
// println!("Went into Identiy Module init");
2024-03-02 10:06:26 -05:00
botlog ::trace (
2024-02-25 10:40:54 -05:00
" Went into Identiy Module init " ,
Some ( " identity.rs > init() " . to_string ( ) ) ,
None ,
) ;
2024-02-12 01:25:12 -05:00
2024-02-12 02:34:32 -05:00
// let a = actions_util::asyncbox(cmd_promote) ;
let tempb = BotCommand {
2024-02-25 10:40:54 -05:00
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 ! [
2024-01-30 09:13:59 -05:00
UserRole ::Mod ( ChType ::Channel ( String ::new ( ) ) ) ,
UserRole ::SupMod ( ChType ::Channel ( String ::new ( ) ) ) ,
UserRole ::Broadcaster ,
UserRole ::BotAdmin ,
2024-02-25 10:40:54 -05:00
] ,
2024-02-12 02:34:32 -05:00
} ;
2024-02-25 10:40:54 -05:00
2024-02-12 05:25:38 -05:00
tempb . add_to_modmgr ( Arc ::clone ( & mgr ) ) . await ;
2024-01-29 11:09:33 -05:00
2024-03-01 23:36:37 -05:00
async fn cmd_promote ( bot : BotAR , msg : PrivmsgMessage ) {
2024-01-29 11:09:33 -05:00
//println!("(#{}) {}: {}", msg.channel_login, msg.sender.name, msg.message_text);
2024-02-13 10:11:49 -05:00
// println!("Called cmd promote");
2024-03-02 10:06:26 -05:00
botlog ::trace (
2024-02-25 10:40:54 -05:00
" Called cmd promote " ,
Some ( " identity.rs > cmd_prommote() " . to_string ( ) ) ,
Some ( & msg ) ,
) ;
2024-01-29 12:41:26 -05:00
2024-01-31 21:30:08 -05:00
// -- 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
2024-01-30 15:07:40 -05:00
/*
- ` promote ` / ` demote `
- [ ] ` SupMod ` & ` Broadcaster ` & ` BotAdmin ` can run
2024-02-25 10:40:54 -05:00
- [ ] ` UserRole ` s that can run , can
2024-01-30 15:07:40 -05:00
- [ ] run ` promote ` on a regular ` Chatter ` to make them a ` Mod `
- [ ] run ` demote ` on a ` Mod ` to make them a ` Chatter `
2024-02-25 10:40:54 -05:00
- [ ] Only ` BotAdmin ` can :
2024-01-30 15:07:40 -05:00
- [ ] target themselves to ` promote ` / ` demote ` , in the case that they want to make themselves either a ` Mod ` or ` SupMod ` for the channel temporarily
2024-02-25 10:40:54 -05:00
- [ ] ` promote admin < Chatter > ` to assign them ` BotAdmin ` role
2024-02-14 01:09:55 -05:00
- ` [ ] Broadcaster ` & ` BotAdmin ` can ` demote ` a ` SupMod ` to make them a ` Mod ` or ` promote ` the other way
2024-01-30 15:07:40 -05:00
* /
2024-01-31 21:30:08 -05:00
/*
2024-02-25 10:40:54 -05:00
Usage :
2024-01-31 21:30:08 -05:00
2024-02-14 01:09:55 -05:00
promote < user >
2024-01-31 21:30:08 -05:00
2024-02-25 10:40:54 -05:00
demote < user >
2024-01-31 21:30:08 -05:00
2024-02-14 01:09:55 -05:00
promote - admin < user >
2024-01-31 21:30:08 -05:00
2024-02-25 10:40:54 -05:00
* /
2024-02-04 14:28:37 -05:00
2024-02-13 10:11:49 -05:00
// println!("{}",msg.message_text);
2024-03-02 10:06:26 -05:00
botlog ::trace (
2024-02-25 10:40:54 -05:00
& format! ( " Twich Message > {} " , msg . message_text ) ,
Some ( " identity.rs > cmd_promote() " . to_string ( ) ) ,
None ,
) ;
2024-02-13 10:11:49 -05:00
2024-02-18 15:23:58 -05:00
let sendername = msg . clone ( ) . sender . name ;
2024-03-01 23:36:37 -05:00
let mut argv = msg . message_text . split ( ' ' ) ;
2024-02-01 08:40:09 -05:00
2024-02-25 10:40:54 -05:00
argv . next ( ) ; // Skip the command name
2024-02-01 08:40:09 -05:00
2024-02-25 10:40:54 -05:00
let arg1 = argv . next ( ) ;
2024-02-01 08:40:09 -05:00
2024-02-25 10:40:54 -05:00
let arg2 = argv . next ( ) ;
2024-02-01 08:40:09 -05:00
2024-02-25 10:40:54 -05:00
let mut sender_badge : Option < ChatBadge > = None ;
2024-02-18 15:23:58 -05:00
2024-02-25 10:40:54 -05:00
for b in & msg . badges {
if b . name = = " moderator " {
sender_badge = Some ( ChatBadge ::Mod ) ;
} else if b . name = = " broadcaster " {
sender_badge = Some ( ChatBadge ::Broadcaster ) ;
}
}
let targetchnl = msg . channel_login . to_lowercase ( ) ;
2024-02-18 15:23:58 -05:00
2024-02-25 10:40:54 -05:00
/*
2024-02-18 15:23:58 -05:00
2024-02-25 10:40:54 -05:00
[ x ] 1. Get trgusr ( regardless of - admin flag )
[ x ] 2. promote trguser
[ x ] 3. Output resulting change
2024-02-18 15:23:58 -05:00
2024-02-25 10:40:54 -05:00
* /
// [x] 1. Get trgusr (regardless of -admin flag)
2024-02-18 15:23:58 -05:00
2024-02-25 10:40:54 -05:00
let targetusr = if arg1 = = Some ( " -admin " ) { arg2 } else { arg1 } ;
2024-02-01 08:40:09 -05:00
2024-02-18 15:23:58 -05:00
// [x] 2. promote trguser
// [x] Get a required lock first
let botlock = bot . read ( ) . await ;
let id = botlock . get_identity ( ) ;
let idlock = id . read ( ) . await ;
let rslt = match targetusr {
Some ( targetusr ) = > {
2024-03-02 10:06:26 -05:00
botlog ::debug (
2024-03-01 23:36:37 -05:00
// &format!("running promote()"),
" running promote() " ,
2024-02-25 10:40:54 -05:00
Some ( " identity.rs > cmd_promote() " . to_string ( ) ) ,
None ,
) ;
2024-02-18 15:23:58 -05:00
Log ::flush ( ) ;
2024-02-25 10:40:54 -05:00
let target_bot_admin_role = if arg1 = = Some ( " -admin " ) {
Some ( UserRole ::BotAdmin )
} else {
None
} ;
2024-02-18 15:23:58 -05:00
2024-02-25 10:40:54 -05:00
idlock
. promote (
sendername . clone ( ) ,
& sender_badge ,
targetusr . to_string ( ) ,
Some ( ChType ::Channel ( targetchnl . clone ( ) ) ) ,
target_bot_admin_role ,
)
. await
2024-02-18 15:23:58 -05:00
}
None = > {
2024-03-02 10:06:26 -05:00
botlog ::debug (
2024-03-01 23:36:37 -05:00
// &format!("No Targer User argument"),
" No Targer User argument " ,
2024-02-25 10:40:54 -05:00
Some ( " identity.rs > cmd_demote() " . to_string ( ) ) ,
None ,
) ;
2024-02-18 15:23:58 -05:00
Log ::flush ( ) ;
ChangeResult ::NoChange ( " No Targer User " . to_string ( ) )
}
} ;
2024-02-25 10:40:54 -05:00
// [x] 3. Output resulting change
2024-02-18 15:23:58 -05:00
match rslt {
ChangeResult ::Success ( a ) = > {
// println!("Succesfully promoted : {a} ;");
let outmsg = & format! ( " o7 Successfully promoted : {a} " ) ;
2024-03-02 10:06:26 -05:00
botlog ::debug (
2024-02-25 10:40:54 -05:00
outmsg ,
Some ( " identity.rs > cmd_prommote() " . to_string ( ) ) ,
Some ( & msg ) ,
) ;
2024-02-18 15:23:58 -05:00
// let outmsg = "o7 Successfully promoted : ".to_string();
2024-02-25 10:40:54 -05:00
botlock
. botmgrs
. chat
. say_in_reply_to ( & msg , outmsg . to_string ( ) )
. await ;
}
2024-02-18 15:23:58 -05:00
ChangeResult ::Failed ( a ) = > {
// println!("Failed to promote : {a} ; ");
let outmsg = & format! ( " PoroSad failed to promote : {a} " ) ;
2024-03-02 10:06:26 -05:00
botlog ::debug (
2024-02-25 10:40:54 -05:00
outmsg ,
Some ( " identity.rs > cmd_prommote() " . to_string ( ) ) ,
Some ( & msg ) ,
) ;
2024-02-18 15:23:58 -05:00
// let outmsg = "PoroSad failed to promote : ".to_string();
2024-02-25 10:40:54 -05:00
botlock
. botmgrs
. chat
. say_in_reply_to ( & msg , outmsg . to_string ( ) )
. await ;
}
2024-02-18 15:23:58 -05:00
ChangeResult ::NoChange ( a ) = > {
// println!("No Changes Made : {a} ; ");
let outmsg = & format! ( " uuh No Promotion Change : {a} " ) ;
2024-03-02 10:06:26 -05:00
botlog ::debug (
2024-02-25 10:40:54 -05:00
outmsg ,
Some ( " identity.rs > cmd_prommote() " . to_string ( ) ) ,
Some ( & msg ) ,
) ;
2024-02-18 15:23:58 -05:00
// let outmsg = "uuh No Promotion Change : ".to_string();
2024-02-25 10:40:54 -05:00
botlock
. botmgrs
. chat
. say_in_reply_to ( & msg , outmsg . to_string ( ) )
. await ;
}
2024-02-18 15:23:58 -05:00
}
2024-02-25 10:40:54 -05:00
/*
match arg1 {
Some ( a1 ) if a1 = = String ::from ( " -admin " ) = > {
// - [x] BotAdmins can promote admin to give BotAdmin UserRole
let botlock = bot . read ( ) . await ;
let idlock = botlock . get_identity ( ) ;
let id = idlock . read ( ) . await ;
// let ta = ta.getspecialuserroles(String::from("Hello"), Some(ChType::Channel(msg.channel_login.to_lowercase())));
// let ta = ta.getspecialuserroles(arg2.unwrap().to_string(), Some(ChType::Channel(msg.channel_login.to_lowercase())));
let rolesfut = id . getspecialuserroles (
msg . sender . name . to_lowercase ( ) ,
Some ( ChType ::Channel ( msg . channel_login . to_lowercase ( ) ) ) ) ;
let usrroles = rolesfut . await ;
// let ta = ta.unwrap();
// let a = ta.read().await;
// let ta = *ta;
// let ta = *ta;
// if let Some(a) = *ta {
if usrroles . contains ( & UserRole ::BotAdmin ) {
// println!("BotAdmin allowed to promote admin");
botinstance ::botlog ::debug ( " BotAdmin allowed to promote admin " ,
Some ( " identity.rs > cmd_prommote() " . to_string ( ) ) , Some ( & msg ) ) ;
{
let idlock = Arc ::clone ( & bot . read ( ) . await . get_identity ( ) ) ;
// let idlock = idlock.write().await;
let idlock = idlock . read ( ) . await ;
// let mut idlock = *idlock;
// let ta = idlock.promote(msg.sender.name.to_lowercase(), None, Some(UserRole::BotAdmin)).await;
let ta = idlock . promote ( arg2 . unwrap ( ) . to_string ( ) . to_lowercase ( ) , None , Some ( UserRole ::BotAdmin ) ) . await ;
match ta {
ChangeResult ::Success ( a ) = > {
// println!("Succesfully promoted : {a} ;");
let outmsg = & format! ( " o7 Successfully promoted : {a} " ) ;
botinstance ::botlog ::debug ( outmsg ,
Some ( " identity.rs > cmd_prommote() " . to_string ( ) ) , Some ( & msg ) ) ;
// let outmsg = "o7 Successfully promoted : ".to_string();
botlock . botmgrs . chat . say_in_reply_to ( & msg , outmsg . to_string ( ) ) . await ;
} ,
ChangeResult ::Failed ( a ) = > {
// println!("Failed to promote : {a} ; ");
let outmsg = & format! ( " PoroSad failed to promote : {a} " ) ;
botinstance ::botlog ::debug ( outmsg ,
Some ( " identity.rs > cmd_prommote() " . to_string ( ) ) , Some ( & msg ) ) ;
// let outmsg = "PoroSad failed to promote : ".to_string();
botlock . botmgrs . chat . say_in_reply_to ( & msg , outmsg . to_string ( ) ) . await ;
} ,
ChangeResult ::NoChange ( a ) = > {
// println!("No Changes Made : {a} ; ");
let outmsg = & format! ( " uuh No Promotion Change : {a} " ) ;
botinstance ::botlog ::debug ( outmsg ,
Some ( " identity.rs > cmd_prommote() " . to_string ( ) ) , Some ( & msg ) ) ;
// let outmsg = "uuh No Promotion Change : ".to_string();
botlock . botmgrs . chat . say_in_reply_to ( & msg , outmsg . to_string ( ) ) . await ;
} ,
}
}
} // if usrroles.contains(&UserRole::BotAdmin)
}
// },
Some ( arg1 ) = > {
// In the case of promoting another chatter
// Check caller's roles
// Check targer chatter's roles
// - Also check if target chatter alread has target roles
// if caller's role is Broadcaster, SupMod, BotAdmin , they can Promote target Chatters to become Mod (i.e., the target user is not a Mod,SupMod,BotAdmin)
// if caller is BotAdmin, they can promote BotAdmins to Mod
// if caller's role is Broadcaster, BotAdmin, they can Promote target Mod to SupMod
botinstance ::botlog ::debug ( & format! ( " Evaluating arg1: {arg1} " ) ,
Some ( " identity.rs > cmd_prommote() " . to_string ( ) ) , Some ( & msg ) ) ;
Log ::flush ( ) ;
let idlock = Arc ::clone ( & bot . read ( ) . await . get_identity ( ) ) ;
let idlock = idlock . read ( ) . await ;
// let ta = idlock.promote(msg.sender.name.to_lowercase(), None, Some(UserRole::BotAdmin)).await;
let senderroles = idlock . getspecialuserroles (
msg . sender . name . to_lowercase ( ) ,
Some ( ChType ::Channel ( msg . channel_login . to_lowercase ( ) ) ) ) . await ;
let trgusrroles = idlock . getspecialuserroles (
arg1 . to_lowercase ( ) ,
Some ( ChType ::Channel ( msg . channel_login . to_lowercase ( ) ) ) ) . await ;
botinstance ::botlog ::debug ( & format! ( " Ready to evaluate sender and targer user roles " ) ,
Some ( " identity.rs > cmd_prommote() " . to_string ( ) ) , Some ( & msg ) ) ;
Log ::flush ( ) ;
botinstance ::botlog ::trace ( & format! ( " Related Vars : sender roles : {:?} ; targer usr roles : {:?} " ,
senderroles , trgusrroles ) ,
Some ( " identity.rs > cmd_prommote() " . to_string ( ) ) , Some ( & msg ) ) ;
Log ::flush ( ) ;
if ( senderroles . contains ( & UserRole ::Broadcaster ) | |
senderroles . contains ( & UserRole ::SupMod ( ChType ::Channel ( msg . channel_login . to_lowercase ( ) ) ) ) | |
senderroles . contains ( & UserRole ::BotAdmin ) ) & &
( ! trgusrroles . contains ( & UserRole ::Broadcaster ) & &
// !trgusrroles.contains(&UserRole::BotAdmin) && // target users that are BotAdmins can promote themselves to Mod or SupMod
! trgusrroles . contains ( & UserRole ::SupMod ( ChType ::Channel ( msg . channel_login . to_lowercase ( ) ) ) ) & &
! trgusrroles . contains ( & UserRole ::Mod ( ChType ::Channel ( msg . channel_login . to_lowercase ( ) ) ) )
)
{
// if caller's role is Broadcaster, SupMod, BotAdmin , they can Promote target Chatters to become Mod (i.e., the target user is not a Mod,SupMod,BotAdmin)
botinstance ::botlog ::trace ( & format! ( " Attempting promote... " ) ,
Some ( " identity.rs > cmd_prommote() " . to_string ( ) ) , Some ( & msg ) ) ;
Log ::flush ( ) ;
let ta = idlock . promote ( arg1 . to_string ( ) . to_lowercase ( ) ,
Some ( ChType ::Channel ( msg . channel_login . to_lowercase ( ) ) ) ,
2024-02-14 01:09:55 -05:00
Some ( UserRole ::Mod ( ChType ::Channel ( msg . channel_login . to_lowercase ( ) ) ) ) ) . await ;
2024-02-25 10:40:54 -05:00
match ta {
ChangeResult ::Success ( a ) = > {
// println!("Succesfully promoted : {a} ;");
let outmsg = & format! ( " Successful Promotion : {a} " ) ;
botinstance ::botlog ::debug ( & format! ( " Successful Promotion : {a} " ) ,
Some ( " identity.rs > cmd_prommote() " . to_string ( ) ) , Some ( & msg ) ) ;
Log ::flush ( ) ;
// let outmsg = "o7 Successfully promoted : ".to_string();
bot . read ( ) . await . botmgrs . chat . say_in_reply_to ( & msg , outmsg . to_string ( ) ) . await ;
} ,
ChangeResult ::Failed ( a ) = > {
// println!("Failed to promote : {a} ; ");
let outmsg = & format! ( " PoroSad failed to promote : {a} " ) ;
botinstance ::botlog ::debug ( outmsg ,
Some ( " identity.rs > cmd_prommote() " . to_string ( ) ) , Some ( & msg ) ) ;
// Log::flush();
// let outmsg = "PoroSad failed to promote : ".to_string();
bot . read ( ) . await . botmgrs . chat . say_in_reply_to ( & msg , outmsg . to_string ( ) ) . await ;
} ,
ChangeResult ::NoChange ( a ) = > {
// println!("No Changes Made : {a} ; ");
let outmsg = & format! ( " uuh Not making any changes : {a} " ) ;
botinstance ::botlog ::debug ( outmsg ,
Some ( " identity.rs > cmd_prommote() " . to_string ( ) ) , Some ( & msg ) ) ;
Log ::flush ( ) ;
// let outmsg = "uuh No Promotion Change : ".to_string();
bot . read ( ) . await . botmgrs . chat . say_in_reply_to ( & msg , outmsg . to_string ( ) ) . await ;
} ,
}
} else if trgusrroles . contains ( & UserRole ::Mod ( ChType ::Channel ( msg . channel_login . to_lowercase ( ) ) ) ) & &
( senderroles . contains ( & UserRole ::Broadcaster ) | |
senderroles . contains ( & UserRole ::BotAdmin ) )
{
botinstance ::botlog ::trace ( & format! ( " Attempting promote... " ) ,
Some ( " identity.rs > cmd_prommote() " . to_string ( ) ) , Some ( & msg ) ) ;
Log ::flush ( ) ;
// broadcaster & botadmins can make mods into SupMod
let ta = idlock . promote ( arg1 . to_string ( ) . to_lowercase ( ) ,
Some ( ChType ::Channel ( msg . channel_login . to_lowercase ( ) ) ) ,
Some ( UserRole ::SupMod ( ChType ::Channel ( msg . channel_login . to_lowercase ( ) ) ) ) ) . await ;
match ta {
ChangeResult ::Success ( a ) = > {
// println!("Succesfully promoted : {a} ;");
let outmsg = & format! ( " Successful Promotion : {a} " ) ;
botinstance ::botlog ::debug ( & format! ( " Successful Promotion : {a} " ) ,
Some ( " identity.rs > cmd_prommote() " . to_string ( ) ) , Some ( & msg ) ) ;
Log ::flush ( ) ;
// let outmsg = "o7 Successfully promoted : ".to_string();
bot . read ( ) . await . botmgrs . chat . say_in_reply_to ( & msg , outmsg . to_string ( ) ) . await ;
} ,
ChangeResult ::Failed ( a ) = > {
// println!("Failed to promote : {a} ; ");
let outmsg = & format! ( " PoroSad failed to promote : {a} " ) ;
botinstance ::botlog ::debug ( outmsg ,
Some ( " identity.rs > cmd_prommote() " . to_string ( ) ) , Some ( & msg ) ) ;
// Log::flush();
// let outmsg = "PoroSad failed to promote : ".to_string();
bot . read ( ) . await . botmgrs . chat . say_in_reply_to ( & msg , outmsg . to_string ( ) ) . await ;
} ,
ChangeResult ::NoChange ( a ) = > {
// println!("No Changes Made : {a} ; ");
let outmsg = & format! ( " uuh No Change in Promotion : {a} " ) ;
botinstance ::botlog ::debug ( outmsg ,
Some ( " identity.rs > cmd_prommote() " . to_string ( ) ) , Some ( & msg ) ) ;
Log ::flush ( ) ;
// let outmsg = "uuh No Promotion Change : ".to_string();
bot . read ( ) . await . botmgrs . chat . say_in_reply_to ( & msg , outmsg . to_string ( ) ) . await ;
} ,
}
} else if trgusrroles . contains ( & UserRole ::Broadcaster ) // This should always be NoChange
{
botinstance ::botlog ::trace ( & format! ( " Attempting promote... " ) ,
Some ( " identity.rs > cmd_prommote() " . to_string ( ) ) , Some ( & msg ) ) ;
Log ::flush ( ) ;
// broadcaster & botadmins can make mods into superadmins
let ta = idlock . promote ( arg1 . to_string ( ) . to_lowercase ( ) ,
Some ( ChType ::Channel ( msg . channel_login . to_lowercase ( ) ) ) ,
Some ( UserRole ::Mod ( ChType ::Channel ( msg . channel_login . to_lowercase ( ) ) ) ) ) . await ;
match ta {
ChangeResult ::Success ( a ) = > {
// println!("Succesfully promoted : {a} ;");
let outmsg = & format! ( " Successful Promotion : {a} " ) ;
botinstance ::botlog ::debug ( & format! ( " Successful Promotion : {a} " ) ,
Some ( " identity.rs > cmd_prommote() " . to_string ( ) ) , Some ( & msg ) ) ;
Log ::flush ( ) ;
// let outmsg = "o7 Successfully promoted : ".to_string();
bot . read ( ) . await . botmgrs . chat . say_in_reply_to ( & msg , outmsg . to_string ( ) ) . await ;
} ,
ChangeResult ::Failed ( a ) = > {
// println!("Failed to promote : {a} ; ");
let outmsg = & format! ( " PoroSad failed to promote : {a} " ) ;
botinstance ::botlog ::debug ( outmsg ,
Some ( " identity.rs > cmd_prommote() " . to_string ( ) ) , Some ( & msg ) ) ;
// Log::flush();
// let outmsg = "PoroSad failed to promote : ".to_string();
bot . read ( ) . await . botmgrs . chat . say_in_reply_to ( & msg , outmsg . to_string ( ) ) . await ;
} ,
ChangeResult ::NoChange ( a ) = > {
// println!("No Changes Made : {a} ; ");
let outmsg = & format! ( " uuh No Change in Promotion : {a} " ) ;
botinstance ::botlog ::debug ( outmsg ,
Some ( " identity.rs > cmd_prommote() " . to_string ( ) ) , Some ( & msg ) ) ;
Log ::flush ( ) ;
// let outmsg = "uuh No Promotion Change : ".to_string();
bot . read ( ) . await . botmgrs . chat . say_in_reply_to ( & msg , outmsg . to_string ( ) ) . await ;
} ,
}
}
else {
let s = botlog ::fatal ( " Reached unreachable else " ,
Some ( " identity > cmd_promote() " . to_string ( ) ) , Some ( & msg ) ) ;
panic! ( " {} " , s ) ;
} ;
Log ::flush ( ) ;
}
_ = > ( ) ,
}
2024-02-14 01:09:55 -05:00
2024-02-13 19:49:36 -05:00
2024-02-01 08:40:09 -05:00
2024-02-25 10:40:54 -05:00
let arg2 = argv . next ( ) ;
2024-02-14 01:09:55 -05:00
2024-02-25 10:40:54 -05:00
let targetchnl = arg2 ;
2024-02-14 01:09:55 -05:00
2024-02-25 10:40:54 -05:00
* /
2024-02-14 01:09:55 -05:00
2024-03-02 10:06:26 -05:00
botlog ::trace (
2024-03-01 23:36:37 -05:00
// &format!("End of cmd_promote()"),
" End of cmd_promote() " ,
2024-02-25 10:40:54 -05:00
Some ( " identity.rs > cmd_prommote() " . to_string ( ) ) ,
None ,
) ;
2024-01-29 11:09:33 -05:00
}
2024-02-12 02:34:32 -05:00
// 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(Arc::clone(&mgr));
let tempb = BotCommand {
2024-02-25 10:40:54 -05:00
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 ! [
2024-01-30 09:13:59 -05:00
UserRole ::Mod ( ChType ::Channel ( String ::new ( ) ) ) ,
UserRole ::SupMod ( ChType ::Channel ( String ::new ( ) ) ) ,
UserRole ::Broadcaster ,
UserRole ::BotAdmin ,
2024-02-25 10:40:54 -05:00
] ,
2024-02-12 02:34:32 -05:00
} ;
2024-02-25 10:40:54 -05:00
2024-02-12 02:34:32 -05:00
tempb . add_to_modmgr ( Arc ::clone ( & mgr ) ) . await ;
2024-01-29 11:09:33 -05:00
2024-02-12 01:25:12 -05:00
// async fn cmd_demote(mut _chat:Arc<Mutex<BotInstance>>,_msg:PrivmsgMessage) {
2024-03-01 23:36:37 -05:00
async fn cmd_demote ( bot : BotAR , msg : PrivmsgMessage ) {
2024-02-13 10:11:49 -05:00
// println!("Called cmd demote");
2024-03-02 10:06:26 -05:00
botlog ::debug (
2024-02-25 10:40:54 -05:00
" Called cmd demote " ,
Some ( " identity.rs > cmd_demote() " . to_string ( ) ) ,
Some ( & msg ) ,
) ;
2024-02-14 01:09:55 -05:00
Log ::flush ( ) ;
2024-02-25 10:40:54 -05:00
2024-02-14 01:09:55 -05:00
// -- If the BotCommand.command was called (e.g., demote) & required roles were validated OUTSIDE of this call
// , this is the current function body to execute
/*
- ` promote ` / ` demote `
- [ ] ` SupMod ` & ` Broadcaster ` & ` BotAdmin ` can run
2024-02-25 10:40:54 -05:00
- [ ] ` UserRole ` s that can run , can
2024-02-14 01:09:55 -05:00
- [ ] run ` promote ` on a regular ` Chatter ` to make them a ` Mod `
- [ ] run ` demote ` on a ` Mod ` to make them a ` Chatter `
2024-02-25 10:40:54 -05:00
- [ ] Only ` BotAdmin ` can :
2024-02-14 01:09:55 -05:00
- [ ] target themselves to ` promote ` / ` demote ` , in the case that they want to make themselves either a ` Mod ` or ` SupMod ` for the channel temporarily
2024-02-25 10:40:54 -05:00
- [ ] ` promote admin < Chatter > ` to assign them ` BotAdmin ` role
2024-02-14 01:09:55 -05:00
- ` [ ] Broadcaster ` & ` BotAdmin ` can ` demote ` a ` SupMod ` to make them a ` Mod ` or ` promote ` the other way
* /
2024-01-29 11:09:33 -05:00
2024-02-14 01:09:55 -05:00
/*
2024-02-25 10:40:54 -05:00
Usage :
2024-02-14 01:09:55 -05:00
promote < user >
2024-02-25 10:40:54 -05:00
demote < user >
2024-02-14 01:09:55 -05:00
promote - admin < user >
2024-02-25 10:40:54 -05:00
2024-02-14 01:09:55 -05:00
* /
2024-01-31 21:30:08 -05:00
2024-02-18 15:23:58 -05:00
// [ ] #TODO : Need to define the body that calls demote()
// [x] Unwraps arguments from message
// let mut argv = msg.message_text.split(" ");
2024-02-25 10:40:54 -05:00
2024-02-18 15:23:58 -05:00
// argv.next(); // Skip the command name
// let arg1 = argv.next();
// let arg2 = argv.next();
2024-03-01 23:36:37 -05:00
let ( arg1 , _arg2 ) = {
let mut argv = msg . message_text . split ( ' ' ) ;
2024-02-25 10:40:54 -05:00
2024-02-18 15:23:58 -05:00
argv . next ( ) ; // Skip the command name
2024-02-25 10:40:54 -05:00
2024-02-18 15:23:58 -05:00
let arg1 = argv . next ( ) ;
let arg2 = argv . next ( ) ;
2024-02-25 10:40:54 -05:00
( arg1 , arg2 )
2024-02-18 15:23:58 -05:00
} ;
/*
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 ) ;
}
}
* /
// ---
/*
2024-02-25 10:40:54 -05:00
= > 2024.0 2.15 - The business logic seems embeded straight into demote ( ) with the following in mind :
- demote ( ) atm doesn ' t take sender ChatBadge < - - the assumption is canuserrun ( ) was done
for this user , and automatically assigned any roles that should get auto assigned
- demote ( ) returns a ChangeResult
2024-02-18 15:23:58 -05:00
2024-02-25 10:40:54 -05:00
- [ ] So I think all I need to do here is parse out and pass input args to demote ( ) , and output quirky messages based on ChangeResult
- [ x ] 1. Parse out the following
- Sender ( e . g . , Name & Badge )
- Target User ( arg1 )
- Target Channel ( current channel )
- Msg or Msg . Message_Text ( for later )
- [ x ] 2. Run Demote ( )
- within demote ( ) , getspecialuserroles ( ) is called on both the sender and the target
- getspecialuserroles ( ) only sends current db , while canuserrun ( ) may change db depending on the most current state of the sender
- getspecialuserroles also borrows the sender ' s badge to evaluate
- [ ] 3. Take ChangeResult and output response
2024-02-18 15:23:58 -05:00
2024-02-25 10:40:54 -05:00
* /
2024-02-18 15:23:58 -05:00
/*
2024-02-25 10:40:54 -05:00
2024-02-18 15:23:58 -05:00
- [ x ] 1. Parse out the following
- Sender ( e . g . , Name & Badge )
- Target User ( arg1 )
- Target Channel ( current channel )
- ( no need ) Msg or Msg . Message_Text ( for later )
2024-02-25 10:40:54 -05:00
* /
2024-02-18 15:23:58 -05:00
let sendername = msg . clone ( ) . sender . name ;
2024-02-25 10:40:54 -05:00
let mut sender_badge_mut : Option < ChatBadge > = None ;
2024-02-18 15:23:58 -05:00
for b in & msg . badges {
if b . name = = " moderator " {
sender_badge_mut = Some ( ChatBadge ::Mod ) ;
} else if b . name = = " broadcaster " {
sender_badge_mut = Some ( ChatBadge ::Broadcaster ) ;
}
}
let sender_badge = sender_badge_mut ;
let targetusr = arg1 ;
let targetchnl = msg . channel_login . to_lowercase ( ) ;
/*
2024-02-25 10:40:54 -05:00
2024-02-18 15:23:58 -05:00
- [ x ] 2. Run Demote ( )
- within demote ( ) , getspecialuserroles ( ) is called on both the sender and the target
- getspecialuserroles ( ) only sends current db , while canuserrun ( ) may change db depending on the most current state of the sender
- getspecialuserroles also borrows the sender ' s badge to evaluate
2024-02-25 10:40:54 -05:00
* /
2024-02-18 15:23:58 -05:00
2024-02-25 10:40:54 -05:00
// [x] Get a required lock first
2024-02-18 15:23:58 -05:00
2024-02-25 10:40:54 -05:00
let botlock = bot . read ( ) . await ;
let id = botlock . get_identity ( ) ;
let idlock = id . read ( ) . await ;
2024-02-18 15:23:58 -05:00
let rslt = match targetusr {
Some ( targetusr ) = > {
2024-03-02 10:06:26 -05:00
botlog ::debug (
2024-03-01 23:36:37 -05:00
// &format!("running demote()"),
" running demote() " ,
2024-02-25 10:40:54 -05:00
Some ( " identity.rs > cmd_demote() " . to_string ( ) ) ,
None ,
) ;
2024-02-18 15:23:58 -05:00
Log ::flush ( ) ;
2024-02-25 10:40:54 -05:00
idlock
. demote (
sendername . clone ( ) ,
& sender_badge ,
targetusr . to_string ( ) ,
Some ( ChType ::Channel ( targetchnl . clone ( ) ) ) ,
)
. await
2024-02-18 15:23:58 -05:00
}
None = > {
2024-03-02 10:06:26 -05:00
botlog ::debug (
2024-03-01 23:36:37 -05:00
// &format!("No Targer User argument"),
" No Targer User argument " ,
2024-02-25 10:40:54 -05:00
Some ( " identity.rs > cmd_demote() " . to_string ( ) ) ,
None ,
) ;
2024-02-18 15:23:58 -05:00
Log ::flush ( ) ;
ChangeResult ::NoChange ( " No Targer User " . to_string ( ) )
}
} ;
/*
2024-02-25 10:40:54 -05:00
2024-02-18 15:23:58 -05:00
- [ x ] 3. Take ChangeResult and output response
2024-02-25 10:40:54 -05:00
* /
2024-02-18 15:23:58 -05:00
// let senderUserRole = {
2024-02-25 10:40:54 -05:00
// // note : getspecialuserroles will cover :
2024-02-18 15:23:58 -05:00
// // - Internal roles stored at db for Mod & SupMod & BotAdmin
// // - Broadcaster (based on target hchatter & channel)
// // It MAY NOT COVER sutations where Sender has a Mod Badge, but not in DB yet as Mod
// // - So ideally this covers that (at least returns that they're a mod and go ahead and run for now)
// // - [ ] #TODO : This should also go ahead and add that mod to DB if possible as channel mod
// // let evalroles = vec![];
// let evalroles = match sender_badge {
// Some(ChatBadge::Mod) => {
// let mut rslroles = idlock.getspecialuserroles(
2024-02-25 10:40:54 -05:00
// sendername.clone(),
2024-02-18 15:23:58 -05:00
// Some(ChType::Channel(targetchnl.clone()))).await;
// rslroles.push(UserRole::Mod(ChType::Channel(targetchnl)));
// rslroles
// },
// _ => {
// idlock.getspecialuserroles(
2024-02-25 10:40:54 -05:00
// sendername,
2024-02-18 15:23:58 -05:00
// Some(ChType::Channel(targetchnl.clone()))).await
// }
// };
2024-02-25 10:40:54 -05:00
// // => 02.16 - I think better would just migrate over the logic within demote
// // - If there's business reqs to evaluate , better to keep the ChangeResult
2024-02-18 15:23:58 -05:00
// // consistent and also pass ChatBadge
// }; // senderUserRole
match rslt {
ChangeResult ::Success ( a ) = > {
// println!("Succesfully promoted : {a} ;");
let outmsg = & format! ( " o7 Successfully demoted : {a} " ) ;
2024-03-02 10:06:26 -05:00
botlog ::debug (
2024-02-25 10:40:54 -05:00
outmsg ,
Some ( " identity.rs > cmd_demote() " . to_string ( ) ) ,
Some ( & msg ) ,
) ;
2024-02-18 15:23:58 -05:00
// let outmsg = "o7 Successfully promoted : ".to_string();
2024-02-25 10:40:54 -05:00
botlock
. botmgrs
. chat
. say_in_reply_to ( & msg , outmsg . to_string ( ) )
. await ;
}
2024-02-18 15:23:58 -05:00
ChangeResult ::Failed ( a ) = > {
// println!("Failed to promote : {a} ; ");
let outmsg = & format! ( " PoroSad failed to demote : {a} " ) ;
2024-03-02 10:06:26 -05:00
botlog ::debug (
2024-02-25 10:40:54 -05:00
outmsg ,
Some ( " identity.rs > cmd_demote() " . to_string ( ) ) ,
Some ( & msg ) ,
) ;
2024-02-18 15:23:58 -05:00
// let outmsg = "PoroSad failed to promote : ".to_string();
2024-02-25 10:40:54 -05:00
botlock
. botmgrs
. chat
. say_in_reply_to ( & msg , outmsg . to_string ( ) )
. await ;
}
2024-02-18 15:23:58 -05:00
ChangeResult ::NoChange ( a ) = > {
// println!("No Changes Made : {a} ; ");
let outmsg = & format! ( " uuh No Demotion Change : {a} " ) ;
2024-03-02 10:06:26 -05:00
botlog ::debug (
2024-02-25 10:40:54 -05:00
outmsg ,
Some ( " identity.rs > cmd_demote() " . to_string ( ) ) ,
Some ( & msg ) ,
) ;
2024-02-18 15:23:58 -05:00
// let outmsg = "uuh No Promotion Change : ".to_string();
2024-02-25 10:40:54 -05:00
botlock
. botmgrs
. chat
. say_in_reply_to ( & msg , outmsg . to_string ( ) )
. await ;
}
2024-02-18 15:23:58 -05:00
}
// println!("tester");
// println!("tester2");
2024-02-14 09:21:50 -05:00
}
2024-02-25 10:40:54 -05:00
let tempcomm = 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 ! [
2024-01-31 21:30:08 -05:00
UserRole ::Mod ( ChType ::Channel ( String ::new ( ) ) ) ,
UserRole ::SupMod ( ChType ::Channel ( String ::new ( ) ) ) ,
UserRole ::Broadcaster ,
UserRole ::BotAdmin ,
2024-02-25 10:40:54 -05:00
] ,
2024-02-12 02:34:32 -05:00
} ;
2024-01-31 21:30:08 -05:00
2024-02-25 10:40:54 -05:00
tempcomm . add_to_modmgr ( Arc ::clone ( & mgr ) ) . await ;
2024-01-31 21:30:08 -05:00
2024-02-12 01:25:12 -05:00
// async fn getroles(bot:Arc<Mutex<BotInstance>>,msg:PrivmsgMessage) {
2024-02-25 10:40:54 -05:00
async fn getroles ( bot : BotAR , msg : PrivmsgMessage ) {
2024-02-13 10:11:49 -05:00
// println!("Called cmd getroles");
2024-03-02 10:06:26 -05:00
botlog ::debug (
2024-02-25 10:40:54 -05:00
" Called cmd getroles " ,
Some ( " identity.rs > cmd_getroles() " . to_string ( ) ) ,
Some ( & msg ) ,
) ;
2024-01-31 21:30:08 -05:00
/*
Usage
getroles < user > < Channel >
2024-02-25 10:40:54 -05:00
- If channel is provided , provide roles for that channel specifically
2024-01-31 21:30:08 -05:00
* /
2024-02-25 10:40:54 -05:00
// IN other code areas , I see this
2024-01-31 21:30:08 -05:00
// ServerMessage::Privmsg(msg) => {
// println!("(#{}) {}: {}", msg.channel_login, msg.sender.name, msg.message_text);
2024-02-01 08:40:09 -05:00
// println!("{}",msg.message_text);
2024-03-01 23:36:37 -05:00
let mut argv = msg . message_text . split ( ' ' ) ;
2024-01-31 21:30:08 -05:00
// for v in argv {
// println!("args : {v}");
// }
2024-02-01 08:40:09 -05:00
argv . next ( ) ; // Skip the command name
2024-01-31 21:30:08 -05:00
let arg1 = argv . next ( ) ;
// if arg == None {
// return ; // Do nothing if no arguments
// }
let targetuser = match arg1 {
2024-02-25 10:40:54 -05:00
None = > return , // exit if no arguments
2024-01-31 21:30:08 -05:00
Some ( arg ) = > arg ,
} ;
// match String::from(arg1) {
// a if a == String::from("admin") => (),
// _ => (),
// }
// match argv[1] {
// String::from("admin") => (),
// }
let arg2 = argv . next ( ) ;
2024-02-25 10:40:54 -05:00
let targetchnl = arg2 ;
2024-01-31 21:30:08 -05:00
2024-02-04 14:28:37 -05:00
// // 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();
2024-02-12 01:25:12 -05:00
// let a = bot.clone();
2024-02-04 14:28:37 -05:00
// let a = a.lock().await;
2024-02-12 01:25:12 -05:00
// let a = a.get_identity();
// let a = a.lock().await;
// let a = bot.get_identity();
let botlock = bot . read ( ) . await ;
2024-02-13 10:11:49 -05:00
// println!("botlock read");
2024-03-02 10:06:26 -05:00
botlog ::trace (
2024-02-25 10:40:54 -05:00
" botlock read " ,
Some ( " identity.rs > init > getroles() " . to_string ( ) ) ,
Some ( & msg ) ,
) ;
2024-02-12 01:25:12 -05:00
let idlock = botlock . get_identity ( ) ;
2024-02-13 10:11:49 -05:00
// println!("got identity");
2024-03-02 10:06:26 -05:00
botlog ::trace (
2024-02-25 10:40:54 -05:00
" got identity " ,
Some ( " identity.rs > init > getroles() " . to_string ( ) ) ,
Some ( & msg ) ,
) ;
2024-02-12 05:25:38 -05:00
let idlock = idlock . read ( ) . await ; // <-- 02.12 - Latest where it gest stuck - before or at this point
2024-02-25 10:40:54 -05:00
// println!("id lock");
2024-03-02 10:06:26 -05:00
botlog ::trace (
2024-02-25 10:40:54 -05:00
" id lock " ,
Some ( " identity.rs > init > getroles() " . to_string ( ) ) ,
Some ( & msg ) ,
) ;
2024-02-04 14:28:37 -05:00
let sproles = match targetchnl {
2024-01-31 21:30:08 -05:00
None = > {
2024-02-04 14:28:37 -05:00
// 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);
2024-02-12 01:25:12 -05:00
// let a = idlock.read().await;
2024-02-13 19:49:36 -05:00
// idlock.getspecialuserroles(String::from(targetuser),None).await
// [ ] If targetchnl is not provided, default to pulling the current channel
2024-02-25 10:40:54 -05:00
idlock
. getspecialuserroles (
String ::from ( targetuser ) ,
Some ( ChType ::Channel ( msg . channel_login . to_lowercase ( ) ) ) ,
)
. await
}
2024-01-31 21:30:08 -05:00
Some ( targetchnl ) = > {
2024-02-04 14:28:37 -05:00
// 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)
2024-02-12 01:25:12 -05:00
// let a = a.read().await;
2024-02-13 19:49:36 -05:00
// [ ] If caller is not a BotAdmin, they can only pull those related to the current channel for the target user
// [ ] If caller is a BotAdmin, allow & return for target channel
// 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 sender_badge {
// Some(ChatBadge::Mod) => {
// } ,
// Some(ChatBadge::Broadcaster) => {
// }
// _ => {
2024-02-25 10:40:54 -05:00
2024-02-13 19:49:36 -05:00
// }
2024-02-25 10:40:54 -05:00
// }
2024-02-13 19:49:36 -05:00
// [x]gets special roles for caller
2024-02-25 10:40:54 -05:00
let callersproles = idlock
. getspecialuserroles (
msg . sender . name . to_lowercase ( ) ,
Some ( ChType ::Channel ( targetchnl . to_lowercase ( ) . to_string ( ) ) ) ,
)
. await ;
2024-02-13 19:49:36 -05:00
// idlock.getspecialuserroles(String::from(targetuser),Some(ChType::Channel(targetchnl.to_lowercase().to_string()))).await
// let a = callersproles.contains(&UserRole::Mod(ChType::Channel(targetchnl.to_lowercase().to_string())));
2024-02-25 10:40:54 -05:00
if callersproles . contains ( & UserRole ::Mod ( ChType ::Channel (
targetchnl . to_lowercase ( ) . to_string ( ) ,
) ) ) | | callersproles . contains ( & UserRole ::SupMod ( ChType ::Channel (
targetchnl . to_lowercase ( ) . to_string ( ) ,
2024-03-01 23:36:37 -05:00
) ) ) | | callersproles . contains ( & UserRole ::Broadcaster )
2024-02-25 10:40:54 -05:00
{
idlock
. getspecialuserroles (
String ::from ( targetuser ) ,
Some ( ChType ::Channel ( targetchnl . to_lowercase ( ) ) ) ,
)
. await
2024-02-13 19:49:36 -05:00
// callersproles
} else {
// Otherwise, don't get the target channel, return the current channel instead
2024-02-25 10:40:54 -05:00
idlock
. getspecialuserroles (
String ::from ( targetuser ) ,
Some ( ChType ::Channel ( msg . channel_login . to_lowercase ( ) ) ) ,
)
. await
2024-02-13 19:49:36 -05:00
}
2024-02-25 10:40:54 -05:00
}
2024-02-04 14:28:37 -05:00
} ;
2024-01-31 21:30:08 -05:00
2024-02-13 19:49:36 -05:00
// let sproles = idlock.getspecialuserroles(String::from(targetuser),).await;
2024-02-13 10:11:49 -05:00
// println!("Retrieved User Roles >> {:?}",sproles);
2024-03-02 10:06:26 -05:00
botlog ::debug (
2024-02-25 10:40:54 -05:00
& format! ( " User roles of Target Chatter >> {:?} " , sproles ) ,
Some ( " identity.rs > init > getroles() " . to_string ( ) ) ,
Some ( & msg ) ,
) ;
2024-02-13 19:49:36 -05:00
// # I believe at this stage I still have botlock active
2024-03-02 10:06:26 -05:00
botlog ::debug (
2024-03-01 23:36:37 -05:00
// &format!("Evaluating special roles"),
" Evaluating special roles " ,
2024-02-25 10:40:54 -05:00
Some ( " identity.rs > init > getroles() " . to_string ( ) ) ,
Some ( & msg ) ,
) ;
2024-02-13 19:49:36 -05:00
// let mut outmsg = String::new();
2024-02-28 00:06:35 -05:00
//let sproles = sproles;
2024-02-13 19:49:36 -05:00
// let arg2 = arg2.unwrap();
2024-01-31 21:30:08 -05:00
2024-02-25 10:40:54 -05:00
let outmsg = if ( ( targetuser . to_lowercase ( ) = = msg . channel_login . to_lowercase ( ) )
& & arg2 . is_none ( ) )
| | ( arg2 . is_some ( ) & & arg2 . unwrap ( ) = = targetuser . to_lowercase ( ) )
{
// First evaluates if they're broadcaster
2024-03-01 23:36:37 -05:00
// let mut outmsg = format!("FeelsWowMan they're the broadcaster. ");
let mut outmsg = " FeelsWowMan they're the broadcaster. " . to_string ( ) ;
2024-02-25 10:40:54 -05:00
if sproles . contains ( & UserRole ::Mod ( ChType ::Channel (
msg . channel_login . to_lowercase ( ) ,
) ) ) | | sproles . contains ( & UserRole ::SupMod ( ChType ::Channel (
msg . channel_login . to_lowercase ( ) ,
) ) ) | | sproles . contains ( & UserRole ::BotAdmin )
{
outmsg = outmsg + & format! ( " Target chatter's user roles are : {:?} " , sproles ) ;
2024-02-13 19:49:36 -05:00
}
2024-02-25 10:40:54 -05:00
outmsg
} else if sproles . contains ( & UserRole ::Mod ( ChType ::Channel (
msg . channel_login . to_lowercase ( ) ,
) ) ) | | sproles . contains ( & UserRole ::SupMod ( ChType ::Channel (
msg . channel_login . to_lowercase ( ) ,
) ) ) | | sproles . contains ( & UserRole ::BotAdmin )
{
format! ( " Target chatter's user roles are : {:?} " , sproles )
} else {
2024-03-01 23:36:37 -05:00
// format!("Target chatter has no special roles LULE ")
" Target chatter has no special roles LULE " . to_string ( )
2024-02-25 10:40:54 -05:00
} ;
2024-02-13 19:49:36 -05:00
2024-02-25 10:40:54 -05:00
// if sproles.contains(&UserRole::Mod(msg.channel_login.to_lowercase())) {
2024-02-13 19:49:36 -05:00
2024-02-25 10:40:54 -05:00
// } else if sproles.contains(&UserRole::Mod(msg.channel_login.to_lowercase())) {
2024-02-13 19:49:36 -05:00
2024-02-25 10:40:54 -05:00
// }
2024-02-13 19:49:36 -05:00
2024-02-25 10:40:54 -05:00
// let outmsg = match sproles
2024-02-13 19:49:36 -05:00
// {
// // let mut outmsg = String::new();
// Some(sproles) => {
// let sproles = sproles.read().await;
// format!("Target chatter's user roles are : {:?}",sproles)
2024-02-25 10:40:54 -05:00
// }
2024-02-13 19:49:36 -05:00
// None => {
// // # NOTE : Broadcaster could be included in this
// // # below is checking if the provided text includes the username
// // let msg = msg.message_text.to_lowercase().contains(&msg.channel_login.to_lowercase());
2024-02-25 10:40:54 -05:00
// botinstance::botlog::debug(&format!("Evaluating special roles > channel login : {} ; message text : {} ; ",&msg.channel_login,&msg.message_text),
2024-02-13 19:49:36 -05:00
// Some("identity.rs > init > getroles()".to_string()), Some(&msg));
// botinstance::botlog::debug(&format!("Evaluating special roles > bool evaluation : {} ",
2024-02-25 10:40:54 -05:00
// msg.message_text.to_lowercase().contains(&msg.channel_login.to_lowercase())),
2024-02-13 19:49:36 -05:00
// Some("identity.rs > init > getroles()".to_string()), Some(&msg));
// if msg.message_text.to_lowercase().contains(&msg.channel_login.to_lowercase()) {
// format!("FeelsWowMan they're the broadcaster ")
// } else {
// format!("Target chatter has no special roles LULE ")
// }
// }
2024-02-25 10:40:54 -05:00
2024-02-13 19:49:36 -05:00
// };
2024-01-31 21:30:08 -05:00
// let a = bot.identity.getuserroles(String::from("ModulatingForce"), Some(ChType::Channel(String::from("ModulatingForcebot"))));
// println!("{:?}",a);
2024-03-02 10:06:26 -05:00
botlog ::debug (
2024-02-25 10:40:54 -05:00
& format! ( " Chat Say Reply message : {:?} " , outmsg ) ,
Some ( " identity.rs > init > getroles() " . to_string ( ) ) ,
Some ( & msg ) ,
) ;
2024-02-13 19:49:36 -05:00
botlock . botmgrs . chat . say_in_reply_to ( & msg , outmsg ) . await ;
2024-02-25 10:40:54 -05:00
// [ ] NOTE : After the above, I should receive only the roles in the context of the current channel I received this ideally and maybe BotAdmin ; not outside
2024-01-31 21:30:08 -05:00
}
2024-02-13 10:11:49 -05:00
// println!("End of Init MOdule add");
2024-03-02 10:06:26 -05:00
botlog ::trace (
2024-02-25 10:40:54 -05:00
" End of Init MOdule add " ,
Some ( " identity.rs > init " . to_string ( ) ) ,
None ,
) ;
2024-01-31 21:30:08 -05:00
2024-02-13 19:49:36 -05:00
Log ::flush ( ) ;
2024-01-29 11:09:33 -05:00
}
2024-01-29 22:57:07 -05:00
// #[derive(Debug, PartialEq, Eq, Hash, Clone)]
// pub enum ChType {
// Channel(String),
// }
2024-02-25 10:40:54 -05:00
#[ derive(Debug, PartialEq, Eq, Clone) ]
2024-01-29 11:09:33 -05:00
pub enum UserRole {
2024-02-25 10:40:54 -05:00
Chatter ,
Mod ( ChType ) , // String specifies Channel
SupMod ( ChType ) , // String specifies Channel
Broadcaster ,
BotAdmin ,
2024-01-29 06:18:27 -05:00
}
2024-01-29 22:57:07 -05:00
pub enum Permissible {
2024-02-25 10:40:54 -05:00
Allow ,
Block ,
2024-01-29 12:41:26 -05:00
}
2024-03-01 23:36:37 -05:00
type UserRolesDB = HashMap < String , Arc < RwLock < Vec < UserRole > > > > ;
2024-01-31 18:36:23 -05:00
#[ derive(Clone) ]
2024-01-29 06:18:27 -05:00
pub struct IdentityManager {
2024-02-04 14:28:37 -05:00
// special_roles_users : HashMap<String,Vec<UserRole>>, // # <-- (!) This must be String instead of ChType because we're checking a User not a Channel
2024-02-12 05:25:38 -05:00
// 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
2024-02-25 10:40:54 -05:00
// special_roles_users : Arc<RwLock<HashMap<String,Vec<UserRole>>>>,
2024-03-01 23:36:37 -05:00
// special_roles_users: Arc<RwLock<HashMap<String, Arc<RwLock<Vec<UserRole>>>>>>,
special_roles_users : Arc < RwLock < UserRolesDB > > ,
2024-01-31 09:31:14 -05:00
// parent_mgr : Box<crate::core::botinstance::BotManagers>,
2024-01-31 21:30:08 -05:00
//parent_mgr : Option<Box<crate::core::botinstance::BotManagers>>,
2024-02-25 10:40:54 -05:00
}
/*
2024-02-18 15:23:58 -05:00
HashMap <
String , < - - Chatter / Username
Vec < UserRole > - - < - - Vectors are basically arrays
>
2024-02-25 10:40:54 -05:00
- - [ ]
2024-02-18 15:23:58 -05:00
let a = vec! [ ]
modulatingforce : vec ! [ UserRole ::BotAdmin ,
UserRole ::Mod ( ChType ::Channel ( " modulatingforcebot " ) ) ]
modulatingforce : vec ! [ UserRole ::BotAdmin ,
UserRole ::Mod ( ChType ::Channel ( " modulatingforcebot " ) ) ]
* /
2024-01-29 06:18:27 -05:00
2024-02-18 15:23:58 -05:00
#[ derive(Debug) ]
2024-01-29 22:57:07 -05:00
pub enum ChatBadge {
2024-01-29 12:41:26 -05:00
Broadcaster ,
Mod ,
}
2024-02-25 10:40:54 -05:00
#[ derive(Debug, PartialEq, Eq) ]
2024-02-13 07:54:35 -05:00
pub enum ChangeResult {
2024-01-31 21:30:08 -05:00
Success ( String ) ,
Failed ( String ) ,
NoChange ( String ) ,
}
2024-01-29 06:18:27 -05:00
impl IdentityManager {
pub fn init ( ) -> IdentityManager {
let mut a = HashMap ::new ( ) ;
for admn in adminvector ( ) {
2024-02-25 10:40:54 -05:00
a . insert (
admn . to_lowercase ( ) ,
Arc ::new ( RwLock ::new ( vec! [ UserRole ::BotAdmin ] ) ) ,
) ;
}
2024-01-29 06:18:27 -05:00
IdentityManager {
2024-02-25 10:40:54 -05:00
special_roles_users : Arc ::new ( RwLock ::new ( a ) ) ,
2024-01-31 21:30:08 -05:00
//parent_mgr : None,
2024-01-29 06:18:27 -05:00
}
}
2024-01-29 12:41:26 -05:00
2024-02-25 10:40:54 -05:00
async fn add_role ( & self , trgchatter : String , trg_role : UserRole ) {
2024-02-18 19:23:50 -05:00
let mut srulock = self . special_roles_users . write ( ) . await ;
let mut usrrolelock = srulock
. get_mut ( & trgchatter )
. expect ( " Error retrieving roles " )
2024-02-25 10:40:54 -05:00
. write ( )
. await ;
usrrolelock . push ( trg_role ) ;
2024-02-18 19:23:50 -05:00
}
2024-02-25 10:40:54 -05:00
async fn remove_role ( & self , trgchatter : String , trg_role : UserRole ) {
2024-02-18 19:23:50 -05:00
let mut srulock = self . special_roles_users . write ( ) . await ;
let mut usrrolelock = srulock
. get_mut ( & trgchatter )
. expect ( " Error retrieving roles " )
2024-02-25 10:40:54 -05:00
. write ( )
. await ;
if let Some ( indx ) = usrrolelock . iter ( ) . position ( | value | * value = = trg_role ) {
2024-02-18 19:23:50 -05:00
usrrolelock . swap_remove ( indx ) ;
//return ChangeResult::Success("Demoted successfully".to_string())
}
}
2024-02-25 10:40:54 -05:00
async fn affirm_chatter_in_db ( & self , trgchatter : String ) {
2024-02-18 19:23:50 -05:00
let mut srulock = self . special_roles_users . write ( ) . await ;
2024-02-25 10:40:54 -05:00
srulock
. entry ( trgchatter . clone ( ) )
. or_insert ( Arc ::new ( RwLock ::new ( vec! [ ] ) ) ) ;
2024-03-02 10:06:26 -05:00
botlog ::trace (
2024-02-25 10:40:54 -05:00
& format! (
" Ensuring User in Roles {:?} " ,
srulock . entry ( trgchatter . clone ( ) )
) ,
Some ( " IdentityManager > affirm_chatter_in_db() " . to_string ( ) ) ,
None ,
) ;
2024-02-18 19:23:50 -05:00
Log ::flush ( ) ;
}
2024-01-29 22:57:07 -05:00
// [ ] Maybe I should create a can_user_run version that simply takes PrvMsg, but then calls can_user_run directly
2024-02-25 10:40:54 -05:00
// pub fn can_user_run_PRVMSG(self,msg:&PrivmsgMessage,cmdreqroles:Vec<UserRole>) -> Result<Permissible,Box<dyn Error>>
2024-02-04 14:28:37 -05:00
// pub fn can_user_run_PRVMSG(&self,msg:&PrivmsgMessage,cmdreqroles:Vec<UserRole>) -> Permissible
2024-02-25 10:40:54 -05:00
// pub async fn can_user_run_PRVMSG(self,msg:&PrivmsgMessage,cmdreqroles:Vec<UserRole>) -> Permissible
2024-03-01 23:36:37 -05:00
pub async fn can_user_run_prvmsg (
2024-02-25 10:40:54 -05:00
& mut self ,
msg : & PrivmsgMessage ,
cmdreqroles : Vec < UserRole > ,
) -> ( Permissible , ChangeResult ) {
2024-01-29 22:57:07 -05:00
// println!("(#{}) {}: {}", msg.channel_login, msg.sender.name, msg.message_text);
// [ ] Check what Badges in PrivmsgMessage
2024-02-13 10:11:49 -05:00
// println!{"Checking within PRVMSG"};
2024-03-02 10:06:26 -05:00
botlog ::debug (
2024-02-25 10:40:54 -05:00
" Checking within PRVMSG " ,
Some ( " identity.rs > can_user_run_PRVMSG() " . to_string ( ) ) ,
2024-03-01 23:36:37 -05:00
// Some(&msg),
Some ( msg ) ,
2024-02-25 10:40:54 -05:00
) ;
2024-01-29 22:57:07 -05:00
2024-02-25 10:40:54 -05:00
let mut sender_badge : Option < ChatBadge > = None ;
2024-01-29 22:57:07 -05:00
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{}) {
// }
2024-02-13 19:49:36 -05:00
// if let Some(sender_badge) = sender_badge {
// match sender_badge {
// Some(sender_badge) => {
2024-02-25 10:40:54 -05:00
// 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;
// return self.can_user_run(msg.sender.name.to_owned(),
// ChType::Channel(msg.channel_login.to_owned()),
// sender_badge,
// cmdreqroles
// ).await
// * NOTE : We're preferring to pass the ChangeResult up , where we have access to Chat via BotInstance
// that have more strained chatting rules
// let evalpermissible = self.can_user_run(msg.sender.name.to_owned(),
// ChType::Channel(msg.channel_login.to_owned()),
// sender_badge,
// cmdreqroles
// ).await ;
// evalpermissible
// // }
// None => {
// }
2024-02-13 19:49:36 -05:00
// here , sender_badge is likely None
// This could be a regular chatter, BotAdmin,SupserMod
2024-01-29 22:57:07 -05:00
// [ ] Call can_user_run()
2024-02-12 01:25:12 -05:00
// (self,Permissible::Block)
2024-02-13 19:49:36 -05:00
// (Permissible::Block,ChangeResult::NoChange("".to_string()))
2024-02-25 10:40:54 -05:00
self . can_user_run (
msg . sender . name . to_owned ( ) ,
ChType ::Channel ( msg . channel_login . to_owned ( ) ) ,
sender_badge ,
cmdreqroles ,
)
. await
2024-01-29 22:57:07 -05:00
}
2024-02-25 10:40:54 -05:00
pub async fn can_user_run (
& mut self ,
usr : String ,
channelname : ChType ,
chat_badge : Option < ChatBadge > ,
cmdreqroles : Vec < UserRole > , // ) -> Result<Permissible,Box<dyn Error>> {
) -> ( Permissible , ChangeResult ) {
// println!{"Checking within can_user_run()"};
2024-03-02 10:06:26 -05:00
botlog ::debug (
2024-02-25 10:40:54 -05:00
& format! (
" Checking within can_user_run() :
2024-02-18 15:23:58 -05:00
usr : { } ; channel : { :? } ; badge : { :? } ; cmdreqroles : { :? } " ,
2024-02-25 10:40:54 -05:00
usr , channelname , chat_badge , cmdreqroles
) ,
Some ( " identity.rs > can_user_run() " . to_string ( ) ) ,
None ,
) ;
/*
canUserRun -
2024-01-29 12:41:26 -05:00
2024-02-25 10:40:54 -05:00
Input :
usr :String ,
channelname :ChType ,
chat_badge :ChatBadge ,
cmdreqroles :Vec < UserRole >
2024-01-29 12:41:26 -05:00
2024-02-25 10:40:54 -05:00
Output : Result < Permissible , Box < dyn Error > >
Some Possible outcomes : Ok ( Permissible ::Allow ) , Ok ( Permissible ::Block )
2024-01-29 12:41:26 -05:00
2024-02-25 10:40:54 -05:00
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
2024-01-29 12:41:26 -05:00
2024-02-25 10:40:54 -05:00
Inputs and business logic determine if the user can run the command based on the command ' s required roles
* /
2024-01-29 12:41:26 -05:00
2024-02-25 10:40:54 -05:00
// 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)
2024-01-29 12:41:26 -05:00
2024-02-25 10:40:54 -05:00
// let idar = Arc::new(RwLock::new(self));
2024-01-29 12:41:26 -05:00
2024-02-25 10:40:54 -05:00
let usr = usr . to_lowercase ( ) ;
2024-01-29 12:41:26 -05:00
2024-03-01 23:36:37 -05:00
// if cmdreqroles.len() == 0 {
if cmdreqroles . is_empty ( ) {
2024-02-25 10:40:54 -05:00
// return Ok(Permissible::Allow)
return (
Permissible ::Allow ,
ChangeResult ::NoChange ( " Command has no required cmdreqroles " . to_string ( ) ) ,
) ;
}
2024-02-12 05:25:38 -05:00
2024-02-25 10:40:54 -05:00
let mut modrolechange = ChangeResult ::NoChange ( " " . to_string ( ) ) ;
2024-02-18 15:23:58 -05:00
2024-02-25 10:40:54 -05:00
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)
Some ( ChatBadge ::Broadcaster ) = > {
if cmdreqroles . contains ( & UserRole ::Broadcaster )
| | cmdreqroles . contains ( & UserRole ::Mod ( ChType ::Channel ( String ::new ( ) ) ) )
| | cmdreqroles . contains ( & UserRole ::SupMod ( ChType ::Channel ( String ::new ( ) ) ) )
{
2024-01-29 22:57:07 -05:00
// return Ok(Permissible::Allow)
2024-02-25 10:40:54 -05:00
return (
Permissible ::Allow ,
ChangeResult ::NoChange ( " Broadcaster Role " . to_string ( ) ) ,
) ;
2024-01-29 22:57:07 -05:00
}
2024-02-25 10:40:54 -05:00
}
2024-01-29 22:57:07 -05:00
2024-02-25 10:40:54 -05:00
// [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)
Some ( ChatBadge ::Mod ) = > {
// println!("Mod Chatbadge detected");
2024-03-02 10:06:26 -05:00
botlog ::info (
2024-02-25 10:40:54 -05:00
" Mod Chatbadge detected " ,
Some ( " identity.rs > can_user_run() " . to_string ( ) ) ,
None ,
) ;
// 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()) {
// println!("Creating clone");
2024-03-02 10:06:26 -05:00
botlog ::trace (
2024-02-25 10:40:54 -05:00
" Creating arc clone " ,
Some ( " identity.rs > can_user_run() " . to_string ( ) ) ,
None ,
) ;
2024-03-01 23:36:37 -05:00
// let roleslock = Arc::clone(&(*self).special_roles_users);
let roleslock = Arc ::clone ( & self . special_roles_users ) ;
2024-02-25 10:40:54 -05:00
// println!("Read lock on : Special_Roles_User"); // <-- after this is slightly different between working and problem
2024-03-02 10:06:26 -05:00
botlog ::trace (
2024-02-25 10:40:54 -05:00
" Read lock on : Special_Roles_User " ,
Some ( " identity.rs > can_user_run() " . to_string ( ) ) ,
None ,
) ;
2024-01-29 22:57:07 -05:00
2024-02-25 10:40:54 -05:00
// {
2024-01-29 22:57:07 -05:00
2024-02-25 10:40:54 -05:00
// // If target user doesn't exist in special_roles_users , add with blank vector roles
// let mut srulock = self.special_roles_users.write().await;
// srulock.entry(usr.clone()).or_insert(Arc::new(RwLock::new(vec![])));
// botinstance::botlog::trace(&format!("Ensuring Chatter in Roles {:?}",srulock.entry(usr.clone())),
// Some("identity.rs > promote()".to_string()), None);
// Log::flush();
// }
self . affirm_chatter_in_db ( usr . clone ( ) ) . await ;
2024-03-01 23:36:37 -05:00
let roleslock = roleslock . write ( ) . await ;
2024-02-25 10:40:54 -05:00
match ( * roleslock ) . get ( & usr . to_lowercase ( ) ) {
Some ( usrroles )
if usrroles
. read ( )
. await
. contains ( & UserRole ::Mod ( channelname . clone ( ) ) )
| | usrroles
. read ( )
. await
. contains ( & UserRole ::SupMod ( channelname . clone ( ) ) ) = >
{
// <-- working got to this point
// println!("contains mod : {}", usrroles.read().await.contains(&UserRole::Mod(channelname.clone())));
// println!("contains supmod : {}", usrroles.read().await.contains(&UserRole::SupMod(channelname.clone())));
// Do nothing when theh have a mod badge and have either a supmod or mod badge for the channel
// println!("Already a mod in roles");
2024-03-02 10:06:26 -05:00
botlog ::trace (
2024-02-25 10:40:54 -05:00
" Already a mod in roles " ,
Some ( " identity.rs > can_user_run() " . to_string ( ) ) ,
None ,
) ;
}
_ = > {
// In the event they have a mod badge , are running a bot command, but don't have a channel mod role yet...
// println!("lock created > adding with a mod role o7");
2024-03-02 10:06:26 -05:00
botlog ::trace (
2024-02-25 10:40:54 -05:00
" lock created > adding with a mod role o7 " ,
Some ( " identity.rs > can_user_run() " . to_string ( ) ) ,
None ,
) ;
2024-03-02 10:06:26 -05:00
// botlog::notice("Assigning ModRole to Chatter",
2024-02-25 10:40:54 -05:00
// Some("identity.rs > can_user_run()".to_string()), None);
let mut roleslock = roleslock ;
2024-03-01 23:36:37 -05:00
let a = roleslock . get_mut ( & usr . to_lowercase ( ) ) . unwrap ( ) ;
2024-02-25 10:40:54 -05:00
let mut alock = a . write ( ) . await ;
alock . push ( UserRole ::Mod ( channelname . clone ( ) ) ) ;
modrolechange = ChangeResult ::Success ( " Auto Promoted Mod " . to_string ( ) ) ;
// alock.get_mut(&usr.to_lowercase())
// .get_or_insert_with(|| UserRole::Mod(channelname.clone()))
// // .expect("ERROR")
// .unwrap()
// .write().await
// // .get_mut()
// .push(UserRole::Mod(channelname.clone()));
} // <-- I'm assuming problem got to here
2024-01-29 22:57:07 -05:00
}
2024-02-25 10:40:54 -05:00
}
_ = > ( ) , // Don't handle other roles here
}
2024-01-29 22:57:07 -05:00
2024-02-25 10:40:54 -05:00
// [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)
2024-01-29 22:57:07 -05:00
2024-02-25 10:40:54 -05:00
// println!("cmd required roles : {:?}",cmdreqroles);
2024-03-02 10:06:26 -05:00
botlog ::trace (
2024-02-25 10:40:54 -05:00
& format! ( " cmd required roles : {:?} " , cmdreqroles ) ,
Some ( " identity.rs > can_user_run() " . to_string ( ) ) ,
None ,
) ;
2024-01-29 22:57:07 -05:00
2024-02-25 10:40:54 -05:00
if cmdreqroles . contains ( & UserRole ::Mod ( ChType ::Channel ( String ::new ( ) ) ) ) {
// match self.special_roles_users.get(&channelname) {
// Some(usrroles) => {},
// None => (),
2024-01-29 22:57:07 -05:00
2024-02-25 10:40:54 -05:00
// }
2024-01-29 22:57:07 -05:00
2024-02-25 10:40:54 -05:00
// println!("Command requires Mod Role");
2024-03-02 10:06:26 -05:00
botlog ::trace (
2024-02-25 10:40:54 -05:00
" Command requires Mod Role " ,
Some ( " identity.rs > can_user_run() " . to_string ( ) ) ,
None ,
) ;
2024-03-01 23:36:37 -05:00
// if let Some(a) = (&*self)
// .special_roles_users
// .read()
// .await
// .get(&usr.to_lowercase())
if let Some ( a ) = self
2024-02-25 10:40:54 -05:00
. special_roles_users
. read ( )
. await
. get ( & usr . to_lowercase ( ) )
{
// println!("Special roles found for user");
2024-03-02 10:06:26 -05:00
botlog ::trace (
2024-02-25 10:40:54 -05:00
" Special roles found for user " ,
Some ( " identity.rs > can_user_run() " . to_string ( ) ) ,
None ,
) ;
if a . read ( ) . await . contains ( & UserRole ::Mod ( channelname . clone ( ) ) )
| | a . read ( )
. await
. contains ( & UserRole ::SupMod ( channelname . clone ( ) ) )
{
// return Ok(Permissible::Allow);
// println!("Special roles found for user : A mod idenfified ");
2024-03-02 10:06:26 -05:00
botlog ::trace (
2024-02-25 10:40:54 -05:00
" > Special Role Identified : Mod " ,
Some ( " identity.rs > can_user_run() " . to_string ( ) ) ,
None ,
) ;
return ( Permissible ::Allow , modrolechange ) ;
2024-01-29 22:57:07 -05:00
}
2024-02-25 10:40:54 -05:00
}
}
2024-01-29 22:57:07 -05:00
2024-02-25 10:40:54 -05:00
// [x] If cmdreqroles includes UserRole::SupMod("") , checks if chatter has UserRole::SupMod(channelname::ChType) to determine if Ok(Permissible::Allow)
2024-01-29 22:57:07 -05:00
2024-02-25 10:40:54 -05:00
if cmdreqroles . contains ( & UserRole ::SupMod ( ChType ::Channel ( String ::new ( ) ) ) ) {
2024-03-01 23:36:37 -05:00
// if let Some(a) = (&*self)
// .special_roles_users
// .read()
// .await
// .get(&usr.to_lowercase())
if let Some ( a ) = self
2024-02-25 10:40:54 -05:00
. special_roles_users
. read ( )
. await
. get ( & usr . to_lowercase ( ) )
{
if a . read ( )
. await
. contains ( & UserRole ::SupMod ( channelname . clone ( ) ) )
{
// return Ok(Permissible::Allow);
return ( Permissible ::Allow , modrolechange ) ;
2024-01-29 22:57:07 -05:00
}
2024-02-25 10:40:54 -05:00
}
}
2024-01-29 22:57:07 -05:00
2024-02-25 10:40:54 -05:00
// [x] If cmdreqroles includes UserRole::BotAdmin and chatter has UserRole::BotAdmin , Ok(Permissible::Allow)
// println!("Eval cmdreqroles with botadmin : {}",cmdreqroles.contains(&UserRole::BotAdmin));
2024-03-02 10:06:26 -05:00
botlog ::trace (
2024-02-25 10:40:54 -05:00
& format! (
" Eval cmdreqroles with botadmin : {} " ,
cmdreqroles . contains ( & UserRole ::BotAdmin )
) ,
Some ( " identity.rs > can_user_run() " . to_string ( ) ) ,
None ,
) ;
if cmdreqroles . contains ( & UserRole ::BotAdmin ) {
// println!("special roles get : {:?}",(&*self).special_roles_users.read().await.get(&usr.to_lowercase()));
2024-03-02 10:06:26 -05:00
botlog ::trace (
2024-02-25 10:40:54 -05:00
& format! (
" special roles get : {:?} " ,
2024-03-01 23:36:37 -05:00
// (&*self)
// .special_roles_users
// .read()
// .await
// .get(&usr.to_lowercase())
self . special_roles_users
2024-02-25 10:40:54 -05:00
. read ( )
. await
. get ( & usr . to_lowercase ( ) )
) ,
Some ( " identity.rs > can_user_run() " . to_string ( ) ) ,
None ,
) ;
2024-03-01 23:36:37 -05:00
// if let Some(a) = (&*self)
if let Some ( a ) = ( self )
2024-02-25 10:40:54 -05:00
. special_roles_users
. read ( )
. await
. get ( & usr . to_lowercase ( ) )
{
println! (
" special roles contains BotAdmin: {} " ,
a . read ( ) . await . contains ( & UserRole ::BotAdmin )
) ;
2024-03-02 10:06:26 -05:00
botlog ::trace (
2024-02-25 10:40:54 -05:00
& format! (
" special roles contains BotAdmin: {} " ,
a . read ( ) . await . contains ( & UserRole ::BotAdmin )
) ,
Some ( " identity.rs > can_user_run() " . to_string ( ) ) ,
None ,
) ;
if a . read ( ) . await . contains ( & UserRole ::BotAdmin ) {
// return Ok(Permissible::Allow);
return ( Permissible ::Allow , modrolechange ) ;
2024-01-29 22:57:07 -05:00
}
2024-02-25 10:40:54 -05:00
}
2024-01-29 12:41:26 -05:00
}
2024-01-31 21:30:08 -05:00
2024-02-25 10:40:54 -05:00
(
Permissible ::Block ,
ChangeResult ::NoChange ( " Not any permissiable condition " . to_string ( ) ) ,
)
}
2024-02-01 08:40:09 -05:00
2024-02-25 10:40:54 -05:00
// pub async fn promote(&mut self,trgchatter:String,channel:Option<ChType>,trg_role:Option<UserRole>) -> ChangeResult {
pub async fn promote (
& self ,
authorizer : String ,
authorizer_badge : & Option < ChatBadge > ,
trgchatter : String ,
channel : Option < ChType > ,
trg_role : Option < UserRole > ,
) -> ChangeResult {
2024-03-02 10:06:26 -05:00
botlog ::trace (
2024-02-25 10:40:54 -05:00
& format! (
2024-02-18 15:23:58 -05:00
" IN VARS for promote() : auth : {} ; authbadge : {:?} ; trg : {} ; Channel {:?} ; {:?} " ,
2024-02-25 10:40:54 -05:00
authorizer , authorizer_badge , trgchatter , channel , trg_role ) ,
Some ( " identity.rs > promote() " . to_string ( ) ) ,
None ,
) ;
2024-02-14 01:09:55 -05:00
Log ::flush ( ) ;
2024-02-01 08:40:09 -05:00
2024-02-18 15:23:58 -05:00
/*
[ x ] 1. Check if Authorizer Mod Badge then Auto Promote to Mod if not Mod
[ x ] 2. Get Authorizer & Target Chatter Roles with a Given Channel
[ x ] 3. If the authorizer & Target Chatters are the same , and the Authorizer is not a Admin , return no change
[ x ] 4 a . If Authorizer is BotAdmin & trg_role is Some ( BotAdmin ) , set Target as BotAdmin and return
[ x ] 4 b . If target is Broadcaster , return NoChange
[ ] 4 c . If Authorizer is a SupMod , Broadcaster , BotAdmin , can Promote Target Chatter > Mod
- NOTE : We do not validate trg_role here - app logic requires you to promote 1 to Mod and 1 more to SupMod
[ ] 4 d . If Authorizer is a Broadcaster , BotAdmin , can Promote a Target Mod > SupMod
- NOTE : We do not validate trg_role here - app logic requires you to promote 1 to Mod and 1 more to SupMod
2024-02-25 10:40:54 -05:00
2024-02-18 15:23:58 -05:00
* /
// [x] 1. Check if Authorizer Mod Badge then Auto Promote to Mod if not Mod
2024-02-18 16:01:28 -05:00
let trgchatter = trgchatter . to_lowercase ( ) ;
2024-02-25 10:40:54 -05:00
let ( authusrroles , trgusrroles ) = if let Some ( channel ) = channel . clone ( ) {
let mut authusrroles = self
. getspecialuserroles ( authorizer . to_lowercase ( ) . clone ( ) , Some ( channel . clone ( ) ) )
2024-02-18 15:23:58 -05:00
. await ;
2024-02-01 08:40:09 -05:00
2024-02-25 10:40:54 -05:00
{
// mut block
2024-02-18 15:23:58 -05:00
// let authusrroles_mut = &mut authusrroles;
// [x] Add Mod(channel) to authusrroles
// [x] #TODO also add to DB if possible?
match * authorizer_badge {
2024-02-25 10:40:54 -05:00
Some ( ChatBadge ::Mod )
if ( ! authusrroles . contains ( & UserRole ::Mod ( channel . clone ( ) ) )
& & ! authusrroles . contains ( & UserRole ::SupMod ( channel . clone ( ) ) ) ) = >
{
2024-02-18 15:23:58 -05:00
// (*authusrroles_mut).push(UserRole::Mod(channel.clone()));
authusrroles . push ( UserRole ::Mod ( channel . clone ( ) ) ) ;
2024-02-18 19:23:50 -05:00
// let mut srulock = self.special_roles_users.write().await;
// srulock
// .get_mut(&trgchatter)
// .expect("Error getting roles")
// // !! [ ] Unsure what happens if promoting a chatter that doesn't exist at
// .write().await
// .push(UserRole::Mod(channel.clone()));
2024-02-19 21:04:01 -05:00
self . affirm_chatter_in_db ( authorizer . clone ( ) ) . await ;
2024-02-25 10:40:54 -05:00
self . add_role ( authorizer . clone ( ) , UserRole ::Mod ( channel . clone ( ) ) )
. await ;
2024-02-18 15:23:58 -05:00
}
2024-02-25 10:40:54 -05:00
_ = > ( ) ,
}
} // mut block
2024-02-18 15:23:58 -05:00
2024-02-25 10:40:54 -05:00
// [x] 2. Get Authorizer & Target Chatter Roles
2024-02-18 15:23:58 -05:00
2024-02-25 10:40:54 -05:00
let trgusrroles = self
. getspecialuserroles ( trgchatter . to_lowercase ( ) . clone ( ) , Some ( channel . clone ( ) ) )
. await ;
2024-02-18 15:23:58 -05:00
2024-02-25 10:40:54 -05:00
( authusrroles , trgusrroles )
} else {
2024-03-01 23:36:37 -05:00
let authusrroles = self
2024-02-25 10:40:54 -05:00
. getspecialuserroles ( authorizer . to_lowercase ( ) . clone ( ) , None )
. await ;
let trgusrroles = self
. getspecialuserroles ( trgchatter . to_lowercase ( ) . clone ( ) , None )
. await ;
( authusrroles , trgusrroles )
} ;
2024-02-18 15:23:58 -05:00
// [x] 3. If the authorizer & Target Chatters are the same, and the Authorizer is not a Admin, return no change
if trgchatter = = authorizer & & ! authusrroles . contains ( & UserRole ::BotAdmin ) {
return ChangeResult ::NoChange ( " Can't target yourself " . to_string ( ) ) ;
}
// [x] 4a. If Authorizer is BotAdmin & trg_role is Some(BotAdmin) , set Target as BotAdmin and return
if authusrroles . contains ( & UserRole ::BotAdmin ) & & trg_role = = Some ( UserRole ::BotAdmin ) {
if trgusrroles . contains ( & UserRole ::BotAdmin ) {
return ChangeResult ::NoChange ( " Already has the role " . to_string ( ) ) ;
} else {
2024-02-18 19:23:50 -05:00
// {
// let mut srulock = self.special_roles_users.write().await;
2024-02-04 14:28:37 -05:00
2024-02-18 19:23:50 -05:00
// srulock.entry(trgchatter.clone()).or_insert(Arc::new(RwLock::new(vec![])));
2024-02-25 10:40:54 -05:00
// botinstance::botlog::trace(&format!("Ensuring Target Chatter in Roles > {:?}",srulock.entry(trgchatter.clone())),
2024-02-18 19:23:50 -05:00
// Some("identity.rs > promote()".to_string()), None);
// Log::flush();
// }
self . affirm_chatter_in_db ( trgchatter . clone ( ) ) . await ;
2024-02-18 15:23:58 -05:00
2024-02-18 19:23:50 -05:00
// {
2024-02-18 15:23:58 -05:00
2024-02-18 19:23:50 -05:00
// let mut srulock = self.special_roles_users.write().await;
2024-02-18 15:23:58 -05:00
2024-02-18 19:23:50 -05:00
// srulock
// .get_mut(&trgchatter)
// .expect("Error getting roles for the user")
// .write().await
// .push(UserRole::BotAdmin); // <-- Adds the specific role
2024-02-25 10:40:54 -05:00
// botinstance::botlog::trace(&format!("Inserting Role > {:?}",srulock.entry(trgchatter.clone())),
2024-02-18 19:23:50 -05:00
// Some("identity.rs > promote()".to_string()), None);
// Log::flush();
// }
self . add_role ( trgchatter . clone ( ) , UserRole ::BotAdmin ) . await ;
2024-02-18 15:23:58 -05:00
return ChangeResult ::Success ( " Promotion Successful " . to_string ( ) ) ;
}
}
// [x] 4b. If target is Broadcaster, return NoChange
if trgusrroles . contains ( & UserRole ::Broadcaster ) {
return ChangeResult ::NoChange ( " Can't target broadcaster " . to_string ( ) ) ;
}
/*
2024-02-25 10:40:54 -05:00
[ ] 4 c . If Authorizer is a SupMod , Broadcaster , BotAdmin , can Promote Target Chatter > Mod
- NOTE : We do not validate trg_role here - app logic requires you to promote 1 to Mod and 1 more to SupMod
[ ] 4 d . If Authorizer is a Broadcaster , BotAdmin , can Promote a Target Mod > SupMod
- NOTE : We do not validate trg_role here - app logic requires you to promote 1 to Mod and 1 more to SupMod
* /
2024-02-18 15:23:58 -05:00
// let authhasnsreqroles = match channel.clone() {
2024-02-25 10:40:54 -05:00
// Some(channel) => authusrroles.contains(&UserRole::SupMod(channel.clone())) ||
// authusrroles.contains(&UserRole::BotAdmin) ||
2024-02-18 15:23:58 -05:00
// authusrroles.contains(&UserRole::Broadcaster) ,
// None => authusrroles.contains(&UserRole::BotAdmin),
2024-02-04 14:28:37 -05:00
// };
2024-02-01 08:40:09 -05:00
2024-02-18 15:23:58 -05:00
if let Some ( trg_chnl ) = channel . clone ( ) {
2024-02-25 10:40:54 -05:00
if ! trgusrroles . contains ( & UserRole ::Broadcaster )
& & ! trgusrroles . contains ( & UserRole ::Mod ( trg_chnl . clone ( ) ) )
& & ! trgusrroles . contains ( & UserRole ::SupMod ( trg_chnl . clone ( ) ) )
{
2024-02-18 15:23:58 -05:00
// target user is neither Mod nor SupMod && not broadcaster
// target's Next Role would be Mod
2024-02-25 10:40:54 -05:00
// Authorizer must be SupMod,Broadcaster,BotAdmin
2024-02-18 15:23:58 -05:00
// > Promote target to Mod
2024-02-25 10:40:54 -05:00
if authusrroles . contains ( & UserRole ::SupMod ( trg_chnl . clone ( ) ) )
| | authusrroles . contains ( & UserRole ::Broadcaster )
2024-02-18 15:23:58 -05:00
| | authusrroles . contains ( & UserRole ::BotAdmin )
{
2024-02-18 19:23:50 -05:00
// {
2024-02-18 15:23:58 -05:00
2024-02-18 19:23:50 -05:00
// // If target user doesn't exist in special_roles_users , add with blank vector roles
// let mut srulock = self.special_roles_users.write().await;
// srulock.entry(trgchatter.clone()).or_insert(Arc::new(RwLock::new(vec![])));
2024-02-25 10:40:54 -05:00
// botinstance::botlog::trace(&format!("Ensuring Chatter in Roles {:?}",srulock.entry(trgchatter.clone())),
2024-02-18 19:23:50 -05:00
// Some("identity.rs > promote()".to_string()), None);
// Log::flush();
// }
self . affirm_chatter_in_db ( trgchatter . clone ( ) ) . await ;
// {
2024-02-25 10:40:54 -05:00
// // promote target after
2024-02-18 19:23:50 -05:00
// let mut srulock = self.special_roles_users.write().await;
// srulock
// .get_mut(&trgchatter)
// .expect("Error getting roles")
// .write().await
// .push(UserRole::Mod(trg_chnl.clone())); // Role to Add
2024-02-25 10:40:54 -05:00
// botinstance::botlog::trace(&format!("Adding Roles to Chatter {:?}",srulock.entry(trgchatter.clone())),
2024-02-18 19:23:50 -05:00
// Some("identity.rs > promote()".to_string()), None);
// Log::flush();
// }
2024-02-25 10:40:54 -05:00
self . add_role ( trgchatter . clone ( ) , UserRole ::Mod ( trg_chnl . clone ( ) ) )
. await ;
2024-02-18 15:23:58 -05:00
2024-02-25 10:40:54 -05:00
return ChangeResult ::Success ( String ::from ( " Promotion Successful " ) ) ;
2024-03-01 23:36:37 -05:00
} else {
// Other else conditions would be mostly spcecial responses like ChangeResult::NoChange or ChangeResult::Fail
// related to authusrroles
2024-02-18 15:23:58 -05:00
return ChangeResult ::Failed ( String ::from ( " You're not permitted to do that " ) ) ;
}
2024-02-25 10:40:54 -05:00
} else if ! trgusrroles . contains ( & UserRole ::Broadcaster )
& & trgusrroles . contains ( & UserRole ::Mod ( trg_chnl . clone ( ) ) )
& & ! trgusrroles . contains ( & UserRole ::SupMod ( trg_chnl . clone ( ) ) )
//
{
2024-02-18 15:23:58 -05:00
// target user is a Mod && not broadcaster
// target's Next Role would be SupMod
// [ ] #todo Check first if target have SupMod - Optional but could be done to cleanup first
2024-02-25 10:40:54 -05:00
// Authorizer must be Broadcaster,BotAdmin
// > Promote target to SupMod
2024-02-18 15:23:58 -05:00
2024-02-25 10:40:54 -05:00
if authusrroles . contains ( & UserRole ::Broadcaster )
| | authusrroles . contains ( & UserRole ::BotAdmin )
2024-02-18 15:23:58 -05:00
{
2024-02-18 19:23:50 -05:00
// { // Inserts user if doesn't exist
// let mut srulock = self.special_roles_users.write().await;
// srulock.entry(trgchatter.clone()).or_insert(Arc::new(RwLock::new(vec![])));
2024-02-25 10:40:54 -05:00
// botinstance::botlog::trace(&format!("Ensuring User in Roles {:?}",srulock.entry(trgchatter.clone())),
2024-02-18 19:23:50 -05:00
// Some("identity.rs > promote()".to_string()), None);
// Log::flush();
// }
self . affirm_chatter_in_db ( trgchatter . clone ( ) ) . await ;
// { // Adds the requested role for the user
// let mut srulock = self.special_roles_users.write().await;
// srulock
// .get_mut(&trgchatter)
// .expect("Error getting roles")
// // !! [ ] Unsure what happens if promoting a chatter that doesn't exist at
// .write().await
// .push(UserRole::SupMod(trg_chnl.clone()));
2024-02-25 10:40:54 -05:00
// botinstance::botlog::trace(&format!("Adding Required Role > {:?}",srulock.entry(trgchatter.clone())),
2024-02-18 19:23:50 -05:00
// Some("identity.rs > promote()".to_string()), None);
// Log::flush();
// }
2024-02-18 15:23:58 -05:00
2024-02-25 10:40:54 -05:00
self . add_role ( trgchatter . clone ( ) , UserRole ::SupMod ( trg_chnl . clone ( ) ) )
. await ;
2024-02-18 19:23:50 -05:00
// { // Removes the lower role (mod) from the user
// let mut srulock = self.special_roles_users.write().await;
// let mut uroleslock = srulock
// .get_mut(&trgchatter)
// .expect("Error getting roles")
// .write().await;
// if let Some(indx) = uroleslock.iter().position(|value| *value == UserRole::Mod(trg_chnl.clone())){
// uroleslock.swap_remove(indx);
// }
2024-02-25 10:40:54 -05:00
// botinstance::botlog::trace(&format!("Removing lower role > {:?}",uroleslock),
2024-02-18 19:23:50 -05:00
// Some("identity.rs > promote()".to_string()), None);
// Log::flush();
// }
2024-02-25 10:40:54 -05:00
self . remove_role ( trgchatter , UserRole ::Mod ( trg_chnl . clone ( ) ) )
. await ;
2024-02-12 05:25:38 -05:00
2024-02-25 10:40:54 -05:00
return ChangeResult ::Success ( String ::from ( " Promotion Successful " ) ) ;
2024-02-18 15:23:58 -05:00
} else {
return ChangeResult ::Failed ( String ::from ( " You're not permitted to do that " ) ) ;
}
2024-02-25 10:40:54 -05:00
} else if ! trgusrroles . contains ( & UserRole ::Broadcaster )
& & trgusrroles . contains ( & UserRole ::SupMod ( trg_chnl . clone ( ) ) )
{
2024-02-18 15:23:58 -05:00
// target user is a SuMod && not broadcaster
// No Change
return ChangeResult ::Failed ( String ::from ( " Already highest available role " ) ) ;
2024-02-25 10:40:54 -05:00
} else {
2024-02-18 15:23:58 -05:00
// since handling for channel is already done, will be handling other trguserroles situations here
2024-02-25 10:40:54 -05:00
// other situations includes :
2024-02-18 15:23:58 -05:00
/*
2024-02-25 10:40:54 -05:00
[ - ] targetuser is broadcaster > > no need - this was done earlier in the function
[ ? ] ?
* /
// At the moment, without any new roles, this should not be reached
2024-03-01 23:36:37 -05:00
// botinstance::botlog::warn(
// &format!("Code Warning : add handing for other trgusrroles"),
// Some("identity.rs > promote()".to_string()),
// None,
// );
2024-03-02 10:06:26 -05:00
botlog ::warn (
2024-03-01 23:36:37 -05:00
" Code Warning : add handing for other trgusrroles " ,
2024-02-25 10:40:54 -05:00
Some ( " identity.rs > promote() " . to_string ( ) ) ,
None ,
) ;
return ChangeResult ::Failed ( String ::from ( " Code Warning " ) ) ;
2024-02-18 15:23:58 -05:00
}
2024-02-25 10:40:54 -05:00
// let trghasreqroles =
2024-02-18 15:23:58 -05:00
// {
// // If target user doesn't exist in special_roles_users , add with blank vector roles
// let mut srulock = self.special_roles_users.write().await;
// srulock.entry(trgchatter.clone()).or_insert(Arc::new(RwLock::new(vec![])));
2024-02-25 10:40:54 -05:00
// botinstance::botlog::trace(&format!("Ensuring Chatter in Roles {:?}",srulock.entry(trgchatter.clone())),
2024-02-18 15:23:58 -05:00
// Some("identity.rs > promote()".to_string()), None);
// Log::flush();
// }
// {
2024-02-25 10:40:54 -05:00
// // promote target after
2024-02-18 15:23:58 -05:00
// let mut srulock = self.special_roles_users.write().await;
// srulock
// .get_mut(&trgchatter)
// .expect("Error getting roles")
// // !! [ ] Unsure what happens if promoting a chatter that doesn't exist at
// .write().await
// .push(UserRole::Mod(trg_chnl.clone())); // Role to Add
2024-02-25 10:40:54 -05:00
// botinstance::botlog::trace(&format!("Adding Roles to Chatter {:?}",srulock.entry(trgchatter.clone())),
2024-02-18 15:23:58 -05:00
// Some("identity.rs > promote()".to_string()), None);
// Log::flush();
// }
// return ChangeResult::Success(String::from("Promotion Successful"));
} ;
// if authhasnsreqroles {
2024-02-25 10:40:54 -05:00
2024-02-18 15:23:58 -05:00
// {
// // If target user doesn't exist in special_roles_users , add with blank vector roles
// let mut srulock = self.special_roles_users.write().await;
// srulock.entry(trgchatter.clone()).or_insert(Arc::new(RwLock::new(vec![])));
2024-02-25 10:40:54 -05:00
// botinstance::botlog::trace(&format!("SRLOCK - 1st write > {:?}",srulock.entry(trgchatter.clone())),
2024-02-18 15:23:58 -05:00
// Some("identity.rs > promote()".to_string()), None);
// Log::flush();
// }
// {
2024-02-25 10:40:54 -05:00
// // promote target after
2024-02-18 15:23:58 -05:00
// let mut srulock = self.special_roles_users.write().await;
// srulock
// .get_mut(&trgchatter)
// .expect("Error getting roles")
// // !! [ ] Unsure what happens if promoting a chatter that doesn't exist at
// .write().await
// .push(UserRole::Mod(trg_chnl));
2024-02-25 10:40:54 -05:00
// botinstance::botlog::trace(&format!("SRLOCK - 2st write > {:?}",srulock.entry(trgchatter.clone())),
2024-02-18 15:23:58 -05:00
// Some("identity.rs > promote()".to_string()), None);
// Log::flush();
// }
// return ChangeResult::Success(String::from("Promotion Successful"));
// }
// authusrroles.contains(&UserRole::Mod(()))
/*
let chatterroles = self . getspecialuserroles ( trgchatter . clone ( ) , channel . clone ( ) ) . await ;
2024-02-25 10:40:54 -05:00
2024-02-18 15:23:58 -05:00
let rolemap = chatterroles ;
2024-02-25 10:40:54 -05:00
2024-02-01 08:40:09 -05:00
match trg_role {
2024-02-14 01:09:55 -05:00
Some ( UserRole ::Mod ( _ ) ) = > {
2024-02-18 15:23:58 -05:00
2024-02-25 10:40:54 -05:00
2024-02-13 19:49:36 -05:00
if let Some ( trg_chnl ) = channel . clone ( ) {
2024-02-18 15:23:58 -05:00
// [ ] 1. If trg_role & trgchatter is a Mod or SupMod of the target channel, return NoChange
2024-02-13 19:49:36 -05:00
let chatterroles = self . getspecialuserroles ( trgchatter . clone ( ) , channel . clone ( ) ) . await ;
let rolemap = chatterroles ;
2024-02-12 05:25:38 -05:00
// let rolemap = rolemap.unwrap();
if rolemap . contains ( & UserRole ::Mod ( trg_chnl . clone ( ) ) ) {
2024-02-01 08:40:09 -05:00
return ChangeResult ::NoChange ( String ::from ( " Target User already has Target Role " ) ) ;
2024-02-14 01:09:55 -05:00
} else if rolemap . contains ( & UserRole ::Broadcaster ) {
return ChangeResult ::NoChange ( String ::from ( " No need to do that for broadcaster " ) ) ;
2024-02-01 08:40:09 -05:00
}
2024-02-14 01:09:55 -05:00
2024-02-01 08:40:09 -05:00
// # otherwise, trg_role for the given chnl is not assigned to the trgchatter
// chatterroles.push(UserRole::Mod(trg_chnl.clone()));
2024-02-13 19:49:36 -05:00
// let a = self.special_roles_users;
// let b = a.write().await;
// // let c = b.get_mut(&trgchatter);
// let c = (*b).;
2024-02-18 15:23:58 -05:00
// [ ] 2. Ensure an entry in Special_Roles_user for trgchatter, and push Mod(Channel) for the Target User
2024-02-13 19:49:36 -05:00
// [x] (!!) AROUND HERE - check if the user exists first, and at least add the user as we're promoting anyway
{
2024-02-18 15:23:58 -05:00
// If target user doesn't exist in special_roles_users , add with blank vector roles
2024-02-13 19:49:36 -05:00
let mut srulock = self . special_roles_users . write ( ) . await ;
srulock . entry ( trgchatter . clone ( ) ) . or_insert ( Arc ::new ( RwLock ::new ( vec! [ ] ) ) ) ;
2024-02-25 10:40:54 -05:00
botinstance ::botlog ::trace ( & format! ( " SRLOCK - 1st write > {:?} " , srulock . entry ( trgchatter . clone ( ) ) ) ,
2024-02-13 19:49:36 -05:00
Some ( " identity.rs > promote() " . to_string ( ) ) , None ) ;
Log ::flush ( ) ;
}
{
2024-02-25 10:40:54 -05:00
// promote target after
2024-02-13 19:49:36 -05:00
let mut srulock = self . special_roles_users . write ( ) . await ;
srulock
. get_mut ( & trgchatter )
. expect ( " Error getting roles " )
// !! [ ] Unsure what happens if promoting a chatter that doesn't exist at
. write ( ) . await
. push ( UserRole ::Mod ( trg_chnl ) ) ;
2024-02-25 10:40:54 -05:00
botinstance ::botlog ::trace ( & format! ( " SRLOCK - 2st write > {:?} " , srulock . entry ( trgchatter . clone ( ) ) ) ,
2024-02-13 19:49:36 -05:00
Some ( " identity.rs > promote() " . to_string ( ) ) , None ) ;
Log ::flush ( ) ;
}
2024-02-01 08:40:09 -05:00
return ChangeResult ::Success ( String ::from ( " Promotion Successful " ) ) ;
2024-02-25 10:40:54 -05:00
}
2024-02-01 08:40:09 -05:00
} ,
2024-02-25 10:40:54 -05:00
Some ( UserRole ::SupMod ( _ ) ) = >
2024-02-14 01:09:55 -05:00
{
if let Some ( trg_chnl ) = channel . clone ( ) {
2024-02-18 15:23:58 -05:00
// [ ] 1. If trg_role & trgchatter is a Mod or SupMod of the target channel, return NoChange
2024-02-14 01:09:55 -05:00
let chatterroles = self . getspecialuserroles ( trgchatter . clone ( ) , channel . clone ( ) ) . await ;
let rolemap = chatterroles ;
// let rolemap = rolemap.unwrap();
if rolemap . contains ( & UserRole ::SupMod ( trg_chnl . clone ( ) ) ) {
return ChangeResult ::NoChange ( String ::from ( " Target User already has Target Role " ) ) ;
} else if rolemap . contains ( & UserRole ::Broadcaster ) {
return ChangeResult ::NoChange ( String ::from ( " No need to do that for broadcaster " ) ) ;
}
// # otherwise, trg_role for the given chnl is not assigned to the trgchatter
// chatterroles.push(UserRole::Mod(trg_chnl.clone()));
// let a = self.special_roles_users;
// let b = a.write().await;
// // let c = b.get_mut(&trgchatter);
// let c = (*b).;
2024-02-25 10:40:54 -05:00
2024-02-18 15:23:58 -05:00
// [ ] 2. Ensure an entry in Special_Roles_user for trgchatter, and push SupMod(Channel) for the Target User
2024-02-14 01:09:55 -05:00
// [x] (!!) AROUND HERE - check if the user exists first, and at least add the user as we're promoting anyway
{
let mut srulock = self . special_roles_users . write ( ) . await ;
srulock . entry ( trgchatter . clone ( ) ) . or_insert ( Arc ::new ( RwLock ::new ( vec! [ ] ) ) ) ;
2024-02-25 10:40:54 -05:00
botinstance ::botlog ::trace ( & format! ( " SRLOCK - 1st write > {:?} " , srulock . entry ( trgchatter . clone ( ) ) ) ,
2024-02-14 01:09:55 -05:00
Some ( " identity.rs > promote() " . to_string ( ) ) , None ) ;
Log ::flush ( ) ;
}
{
let mut srulock = self . special_roles_users . write ( ) . await ;
srulock
. get_mut ( & trgchatter )
. expect ( " Error getting roles " )
// !! [ ] Unsure what happens if promoting a chatter that doesn't exist at
. write ( ) . await
. push ( UserRole ::SupMod ( trg_chnl . clone ( ) ) ) ;
2024-02-25 10:40:54 -05:00
botinstance ::botlog ::trace ( & format! ( " SRLOCK - 2st write > {:?} " , srulock . entry ( trgchatter . clone ( ) ) ) ,
2024-02-14 01:09:55 -05:00
Some ( " identity.rs > promote() " . to_string ( ) ) , None ) ;
Log ::flush ( ) ;
}
{
let mut srulock = self . special_roles_users . write ( ) . await ;
// srulock
// .get_mut(&trgchatter)
// .expect("Error getting roles")
// // !! [ ] Unsure what happens if promoting a chatter that doesn't exist at
// .write().await
// .(UserRole::Mod(trg_chnl));
// let indx = srulock.iter().position()
let mut uroleslock = srulock
. get_mut ( & trgchatter )
. expect ( " Error getting roles " )
// !! [ ] Unsure what happens if promoting a chatter that doesn't exist at
. write ( ) . await ;
if let Some ( indx ) = uroleslock . iter ( ) . position ( | value | * value = = UserRole ::Mod ( trg_chnl . clone ( ) ) ) {
uroleslock . swap_remove ( indx ) ;
}
2024-02-25 10:40:54 -05:00
botinstance ::botlog ::trace ( & format! ( " SRLOCK - 2st write > {:?} " , uroleslock ) ,
2024-02-14 01:09:55 -05:00
Some ( " identity.rs > promote() " . to_string ( ) ) , None ) ;
Log ::flush ( ) ;
}
return ChangeResult ::Success ( String ::from ( " Promotion Successful " ) ) ;
}
} ,
2024-02-13 19:49:36 -05:00
Some ( UserRole ::BotAdmin ) = > {
2024-02-25 10:40:54 -05:00
2024-02-18 15:23:58 -05:00
2024-02-13 19:49:36 -05:00
let chatterroles = self . getspecialuserroles ( trgchatter . clone ( ) , channel . clone ( ) ) . await ;
let rolemap = chatterroles ;
2024-02-25 10:40:54 -05:00
botinstance ::botlog ::trace ( & format! ( " Target Role : BotAdmin " ) ,
2024-02-13 19:49:36 -05:00
Some ( " identity.rs > promote() " . to_string ( ) ) , None ) ;
// [x] 1. Check their roles first if they already have botadmin
2024-02-25 10:40:54 -05:00
// [x] 2. Know that prior to promote() , BotAdmins should have been validated before being able to pass the BotAdmin target
2024-02-13 19:49:36 -05:00
// [x] 1. Check target chatter's roles first if they already have botadmin
2024-02-25 10:40:54 -05:00
botinstance ::botlog ::trace ( & format! ( " Eval rolemap.contains(BotAdmin) : {} " , rolemap . contains ( & UserRole ::BotAdmin ) ) ,
2024-02-13 19:49:36 -05:00
Some ( " identity.rs > promote() " . to_string ( ) ) , None ) ;
2024-02-25 10:40:54 -05:00
botinstance ::botlog ::trace ( & format! ( " Eval rolemap.contains(BotAdmin) > Rolemap : {:?} " , rolemap ) ,
2024-02-13 19:49:36 -05:00
Some ( " identity.rs > promote() " . to_string ( ) ) , None ) ;
// [ ] (!) This seems to be an issue - rolemap by this point is blank
if rolemap . contains ( & UserRole ::BotAdmin ) {
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()));
2024-02-25 10:40:54 -05:00
2024-02-13 19:49:36 -05:00
// [x] (!!) AROUND HERE - check if the user exists first, and at least add the user as we're promoting anyway
{
let mut srulock = self . special_roles_users . write ( ) . await ;
srulock . entry ( trgchatter . clone ( ) ) . or_insert ( Arc ::new ( RwLock ::new ( vec! [ ] ) ) ) ;
2024-02-25 10:40:54 -05:00
botinstance ::botlog ::trace ( & format! ( " SRLOCK - 1st write > {:?} " , srulock . entry ( trgchatter . clone ( ) ) ) ,
2024-02-13 19:49:36 -05:00
Some ( " identity.rs > promote() " . to_string ( ) ) , None ) ;
Log ::flush ( ) ;
}
{
let mut srulock = self . special_roles_users . write ( ) . await ;
srulock
. get_mut ( & trgchatter )
// !! [ ] Unsure what happens if promoting a chatter that doesn't exist at
. expect ( " Error getting roles " )
. write ( ) . await
. push ( UserRole ::BotAdmin ) ;
2024-02-25 10:40:54 -05:00
botinstance ::botlog ::trace ( & format! ( " SRLOCK - 2nd write > {:?} " , srulock . entry ( trgchatter . clone ( ) ) ) ,
2024-02-13 19:49:36 -05:00
Some ( " identity.rs > promote() " . to_string ( ) ) , None ) ;
Log ::flush ( ) ;
}
2024-02-25 10:40:54 -05:00
botinstance ::botlog ::trace ( & format! ( " Target Role : BotAdmin >> Successful " ) ,
2024-02-13 19:49:36 -05:00
Some ( " identity.rs > promote() " . to_string ( ) ) , None ) ;
return ChangeResult ::Success ( String ::from ( " Promotion Successful " ) ) ;
} ,
2024-02-14 09:21:50 -05:00
Some ( _ ) = > {
2024-02-25 10:40:54 -05:00
botinstance ::botlog ::warn ( & format! ( " Runtime reached undeveloped code " ) ,
2024-02-14 09:21:50 -05:00
Some ( " identity.rs > promote() " . to_string ( ) ) , None ) ;
} ,
None = > {
2024-02-25 10:40:54 -05:00
botinstance ::botlog ::warn ( & format! ( " Runtime reached undeveloped code " ) ,
2024-02-14 09:21:50 -05:00
Some ( " identity.rs > promote() " . to_string ( ) ) , None ) ;
} ,
2024-02-01 08:40:09 -05:00
}
2024-02-18 15:23:58 -05:00
* /
2024-02-01 08:40:09 -05:00
// 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"));
2024-02-25 10:40:54 -05:00
// }
2024-02-01 08:40:09 -05:00
2024-02-25 10:40:54 -05:00
// // By this point, chatteroles does not contain target role
2024-02-01 08:40:09 -05:00
// // match trgRole {
// // Some(trgRole) => {
// // match trgRole {
// // UserRole::Mod(a) => {
2024-02-25 10:40:54 -05:00
2024-02-01 08:40:09 -05:00
// // },
// // UserRole::SupMod(a) => (),
// // UserRole::BotAdmin => (),
2024-02-25 10:40:54 -05:00
// // _ => (), // <-- do nothing with al other options
2024-02-01 08:40:09 -05:00
// // }
// // },
// // None => {
// // /*
2024-02-25 10:40:54 -05:00
// // - If trgRole is None , then promote by implicit rules . For example,
2024-02-01 08:40:09 -05:00
// // - For UserRoles without Mod or SupMod & Caller is SupMod | Broadcaster | BotAdmin > To Mod
// // - For Mod & Caller is SupMod | Broadcaster | BotAdmin > To SupMod
2024-02-25 10:40:54 -05:00
// // - For UserRoles without BotAdmin & Caller is BotAdmin > To BotAdmin
2024-02-01 08:40:09 -05:00
// // */
// // },
// // }
// // let trgRole = match trgRole {
// // Some(UserRole::Mod(a)) => a,
// // Some(UserRole::SupMod(a)) => a,
// // Some(UserRole::BotAdmin) => UserRole::BotAdmin,
// // None => {
// // /*
2024-02-25 10:40:54 -05:00
// // - If trgRole is None , then promote by implicit rules . For example,
2024-02-01 08:40:09 -05:00
// // - For UserRoles without Mod or SupMod & Caller is SupMod | Broadcaster | BotAdmin > To Mod
// // - For Mod & Caller is SupMod | Broadcaster | BotAdmin > To SupMod
2024-02-25 10:40:54 -05:00
// // - For UserRoles without BotAdmin & Caller is BotAdmin > To BotAdmin
2024-02-01 08:40:09 -05:00
// // */
// // },
// // };
// // 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::
// // }
// },
// _ => (),
// }
2024-03-01 23:36:37 -05:00
// botinstance::botlog::warn(
// &format!("Runtime reached undeveloped code"),
// Some("identity.rs > promote()".to_string()),
// None,
// );
2024-03-02 10:06:26 -05:00
botlog ::warn (
2024-03-01 23:36:37 -05:00
" Runtime reached undeveloped code " ,
2024-02-25 10:40:54 -05:00
Some ( " identity.rs > promote() " . to_string ( ) ) ,
None ,
) ;
2024-02-18 15:23:58 -05:00
ChangeResult ::Failed ( String ::from ( " ERROR " ) )
2024-02-25 10:40:54 -05:00
}
2024-01-31 21:30:08 -05:00
2024-02-25 10:40:54 -05:00
pub async fn demote (
& self ,
authorizer : String ,
authorizer_badge : & Option < ChatBadge > ,
trgchatter : String ,
channel : Option < ChType > ,
2024-02-18 15:23:58 -05:00
// trg_role:Option<UserRole>
2024-02-25 10:40:54 -05:00
) -> ChangeResult {
2024-02-18 15:23:58 -05:00
// botinstance::botlog::trace(&format!("IN VARS for demote() : Authorizer : {:?} ; Target Chatter : {} ; Target Channel : {:?} ; Targer Role {:?}",
2024-02-25 10:40:54 -05:00
// authorizer,trgchatter,channel,trg_role),
2024-03-02 10:06:26 -05:00
botlog ::trace ( & format! ( " IN VARS for demote() : Authorizer : {:?} ; Target Chatter : {} ; Target Channel : {:?} " ,
2024-02-25 10:40:54 -05:00
authorizer , trgchatter , channel ) , Some ( " identity.rs > demote() " . to_string ( ) ) , None ) ;
2024-02-14 09:21:50 -05:00
Log ::flush ( ) ;
/*
2024-02-25 10:40:54 -05:00
Check authorizer roles ( if any ) for the target channel
Check Targer User ' s roles ( if any ) for the target channel
Target Channel may be NONE in the case of Non - Channel related roles ( FUTURE ENH )
2024-02-14 09:21:50 -05:00
2024-02-25 10:40:54 -05:00
Use the roles of the above to determine whether the authorizer can demote the target user or not
* /
2024-02-14 09:21:50 -05:00
2024-02-18 15:23:58 -05:00
// [x] 1. If Authorizer's Badge is Mod, ensuring Sender is in DB as Mod(Channel)
2024-02-18 16:01:28 -05:00
let trgchatter = trgchatter . to_lowercase ( ) ;
2024-02-14 09:21:50 -05:00
if let Some ( channel ) = channel {
2024-02-25 10:40:54 -05:00
let mut authusrroles = self
. getspecialuserroles ( authorizer . to_lowercase ( ) . clone ( ) , Some ( channel . clone ( ) ) )
2024-02-14 09:21:50 -05:00
. await ;
// let authusrroles = authusrroles;
2024-02-18 15:23:58 -05:00
{
// let authusrroles_mut = &mut authusrroles;
// [x] Add Mod(channel) to authusrroles
// [x] #TODO also add to DB if possible?
match * authorizer_badge {
2024-02-25 10:40:54 -05:00
Some ( ChatBadge ::Mod )
if ( ! authusrroles . contains ( & UserRole ::Mod ( channel . clone ( ) ) )
& & ! authusrroles . contains ( & UserRole ::SupMod ( channel . clone ( ) ) ) ) = >
{
2024-02-18 15:23:58 -05:00
// (*authusrroles_mut).push(UserRole::Mod(channel.clone()));
authusrroles . push ( UserRole ::Mod ( channel . clone ( ) ) ) ;
2024-02-18 19:23:50 -05:00
// [ ] below pushes mod to authorizer
// let mut srulock = self.special_roles_users.write().await;
// srulock
// .get_mut(&trgchatter)
// .expect("Error getting roles")
// // !! [ ] Unsure what happens if promoting a chatter that doesn't exist at
// .write().await
// .push(UserRole::Mod(channel.clone()));
2024-02-25 10:40:54 -05:00
self . add_role ( authorizer . clone ( ) , UserRole ::Mod ( channel . clone ( ) ) )
. await ;
2024-02-18 15:23:58 -05:00
}
_ = > ( ) ,
}
}
// [x] 2. Targer User's Vec<UserRole>
2024-02-14 09:21:50 -05:00
2024-02-25 10:40:54 -05:00
let trgusrroles = self
. getspecialuserroles ( trgchatter . to_lowercase ( ) . clone ( ) , Some ( channel . clone ( ) ) )
2024-02-14 09:21:50 -05:00
. await ;
2024-02-18 15:23:58 -05:00
// [x] 3. Return if Authorizer & Target are same chatter and Authorizer is not a BotAdmin
if trgchatter = = authorizer & & ! authusrroles . contains ( & UserRole ::BotAdmin ) {
2024-02-25 10:40:54 -05:00
return ChangeResult ::NoChange ( " Can't target yourself " . to_string ( ) ) ;
2024-02-18 15:23:58 -05:00
}
// [x] 4a. Authorizers who are BotAdmin, Broadcaster or Supermod can demote a Mod
2024-02-25 10:40:54 -05:00
if ( authusrroles . contains ( & UserRole ::BotAdmin )
| | authusrroles . contains ( & UserRole ::Broadcaster )
| | authusrroles . contains ( & UserRole ::SupMod ( channel . clone ( ) ) ) )
& & trgusrroles . contains ( & UserRole ::Mod ( channel . clone ( ) ) )
{
// // [ ] Below removes Mod from trgchatter
// let mut srulock = self.special_roles_users.write().await;
// let mut usrrolelock = srulock
// .get_mut(&trgchatter)
// .expect("Error getting roles")
// .write().await;
// if let Some(indx) = usrrolelock.iter().position(|value| *value == UserRole::Mod(channel.clone())){
// usrrolelock.swap_remove(indx);
// return ChangeResult::Success("Demoted successfully".to_string())
// }
self . remove_role ( trgchatter . clone ( ) , UserRole ::Mod ( channel . clone ( ) ) )
. await ;
return ChangeResult ::Success ( " Demoted successfully " . to_string ( ) ) ;
}
2024-02-18 15:23:58 -05:00
// [x] 4b. Authorizers who are BotAdmin, Broadcaster can demote a SupMod
2024-02-25 10:40:54 -05:00
else if ( authusrroles . contains ( & UserRole ::BotAdmin )
| | authusrroles . contains ( & UserRole ::Broadcaster ) )
& & trgusrroles . contains ( & UserRole ::SupMod ( channel . clone ( ) ) )
{
// [ ] For Trgchatter, below pushes Mod UserRole and removes SupMod
// let mut srulock = self.special_roles_users.write().await;
// let mut usrrolelock = srulock
// .get_mut(&trgchatter)
// .expect("Error getting roles")
// .write().await;
// usrrolelock.push(UserRole::Mod(channel.clone())); // pushes Mod , and removes SupMod
// if let Some(indx) = usrrolelock.iter().position(|value| *value == UserRole::SupMod(channel.clone())){
// usrrolelock.swap_remove(indx);
// return ChangeResult::Success("Demoted successfully".to_string())
// }
2024-02-18 19:23:50 -05:00
2024-02-25 10:40:54 -05:00
self . add_role ( trgchatter . clone ( ) , UserRole ::Mod ( channel . clone ( ) ) )
. await ;
self . remove_role ( trgchatter . clone ( ) , UserRole ::SupMod ( channel . clone ( ) ) )
. await ;
return ChangeResult ::Success ( " Demoted successfully " . to_string ( ) ) ;
}
2024-02-18 15:23:58 -05:00
// [x] 4c. When Target chatter isnt a Mod or SupMod to demote
2024-02-25 10:40:54 -05:00
else if ! trgusrroles . contains ( & UserRole ::Mod ( channel . clone ( ) ) )
& & ! trgusrroles . contains ( & UserRole ::SupMod ( channel . clone ( ) ) )
{
return ChangeResult ::Failed (
" Target chatter does not have a role that can be demoted " . to_string ( ) ,
) ;
}
2024-02-18 16:01:28 -05:00
// [x] 4d. When they're only a Mod
2024-02-18 15:23:58 -05:00
else if authusrroles . contains ( & UserRole ::Mod ( channel . clone ( ) ) ) {
2024-02-25 10:40:54 -05:00
return ChangeResult ::Failed ( " You're not permitted to do that " . to_string ( ) ) ;
2024-02-18 15:23:58 -05:00
}
2024-02-14 09:21:50 -05:00
}
2024-03-01 23:36:37 -05:00
// botinstance::botlog::warn(&format!("Potential Unhandled Demotion Condition : Consider explicitely adding in for better handling"),
// Some("identity.rs > demote()".to_string()), None);
2024-03-02 10:06:26 -05:00
botlog ::warn ( " Potential Unhandled Demotion Condition : Consider explicitely adding in for better handling " ,
2024-03-01 23:36:37 -05:00
Some ( " identity.rs > demote() " . to_string ( ) ) , None ) ;
2024-02-18 15:23:58 -05:00
Log ::flush ( ) ;
2024-02-14 09:21:50 -05:00
ChangeResult ::Failed ( String ::from ( " Did not meet criteria to demote succesfully " ) )
2024-01-31 21:30:08 -05:00
}
2024-02-13 19:49:36 -05:00
// pub async fn getspecialuserroles(&self,chattername:String,channel:Option<ChType>) -> Option<Arc<RwLock<Vec<UserRole>>>> {
2024-02-18 15:23:58 -05:00
pub async fn getspecialuserroles (
2024-02-25 10:40:54 -05:00
& self ,
chattername : String ,
channel : Option < ChType > ,
) -> Vec < UserRole > {
2024-02-12 05:25:38 -05:00
/*
2024-02-25 10:40:54 -05:00
Note : Ideally this be called for a given chatter name ?
* /
2024-02-13 19:49:36 -05:00
// [ ] !!! TODO: I don't think below is evaluating by given channel
2024-03-02 10:06:26 -05:00
botlog ::debug (
2024-02-25 10:40:54 -05:00
& format! (
" IN VARS > chattername {} ; channel {:?} " ,
chattername , channel
) ,
Some ( " IdentityManager > getspecialuserroles() " . to_string ( ) ) ,
None ,
) ;
2024-02-13 19:49:36 -05:00
// resulting vector
let mut evalsproles = vec! [ ] ;
2024-01-31 21:30:08 -05:00
2024-02-12 05:25:38 -05:00
let chattername = chattername . to_lowercase ( ) ;
2024-01-31 21:30:08 -05:00
2024-02-13 19:49:36 -05:00
// Checks if broadcaster
let channel_out = match channel {
Some ( channel_tmp ) = > {
match channel_tmp {
ChType ::Channel ( channel_tmp ) = > {
// In this block, Some input channel is given
// We're comparing the channel name with chattername to determine if they're a broadcaster
if chattername = = channel_tmp . to_lowercase ( ) {
evalsproles . push ( UserRole ::Broadcaster ) ;
}
Some ( ChType ::Channel ( channel_tmp ) )
2024-02-25 10:40:54 -05:00
} // _ => ()
2024-02-13 19:49:36 -05:00
}
}
None = > None ,
} ;
2024-02-12 05:25:38 -05:00
let rolesa = Arc ::clone ( & self . special_roles_users ) ;
let a = rolesa . read ( ) . await ;
// let a = Arc::clone(a)
2024-02-29 08:52:41 -05:00
//let a = a;
2024-02-13 19:49:36 -05:00
let vecroles = & ( * a ) ;
let vecroles = vecroles . get ( & chattername ) ;
match vecroles {
Some ( a ) = > {
// [ ] This needs to take the user roles for the user, then yield only the one for the channel if channel is explicitely provided
// Some(Arc::clone(a))
match channel_out {
Some ( channel ) = > {
// let eval = a.read().await.contains(&UserRole::Mod(channel));
// let eval = a.read().await.contains(&UserRole::SupMod(channel));
2024-03-02 10:06:26 -05:00
botlog ::debug (
2024-02-25 10:40:54 -05:00
& format! ( " INTERNAL > All Roles found {:?} " , & a ) ,
Some ( " IdentityManager > getspecialuserroles() " . to_string ( ) ) ,
None ,
) ;
2024-02-13 19:49:36 -05:00
// a.read().await.contains(&UserRole::BotAdmin)
2024-03-02 10:06:26 -05:00
botlog ::trace (
2024-02-25 10:40:54 -05:00
& format! (
" INTERNAL > eval special roles contains botadmin : {:?} " ,
a . read ( ) . await . contains ( & UserRole ::BotAdmin )
) ,
Some ( " IdentityManager > getspecialuserroles() " . to_string ( ) ) ,
None ,
) ;
2024-02-13 19:49:36 -05:00
if a . read ( ) . await . contains ( & UserRole ::BotAdmin ) {
evalsproles . push ( UserRole ::BotAdmin ) ;
2024-02-25 10:40:54 -05:00
}
2024-02-13 19:49:36 -05:00
if a . read ( ) . await . contains ( & UserRole ::Mod ( channel . clone ( ) ) ) {
evalsproles . push ( UserRole ::Mod ( channel . clone ( ) ) ) ;
}
if a . read ( ) . await . contains ( & UserRole ::SupMod ( channel . clone ( ) ) ) {
evalsproles . push ( UserRole ::SupMod ( channel . clone ( ) ) ) ;
2024-02-25 10:40:54 -05:00
}
2024-02-13 19:49:36 -05:00
// else {};
2024-02-25 10:40:54 -05:00
}
2024-02-13 19:49:36 -05:00
None = > {
2024-02-25 10:40:54 -05:00
// here , do nothing if the channel not provided
// [ ] TODO : Future is to provide all maybe ?
// ... no I think missing this is an issue for when the flag is -admin and channel is None?
//
// => 02.13 - Decided That None is provided as a Channel, we can output non-channel related roles like BotAdmin
if a . read ( ) . await . contains ( & UserRole ::BotAdmin ) {
2024-02-13 19:49:36 -05:00
evalsproles . push ( UserRole ::BotAdmin ) ;
2024-02-25 10:40:54 -05:00
}
2024-02-13 19:49:36 -05:00
}
}
2024-02-25 10:40:54 -05:00
}
2024-02-13 19:49:36 -05:00
None = > {
// here, the user has no special listed roles. Note though Broadcaster is not stored in special roles
// Do nothing in this case
// There may be an issue if the chattername does not exist at the moment in special_roles_users
2024-02-25 10:40:54 -05:00
// In this case, evalsproles would only contain Broadcaster flags if any
}
2024-02-12 05:25:38 -05:00
}
2024-02-04 14:28:37 -05:00
2024-03-02 10:06:26 -05:00
botlog ::debug (
2024-02-25 10:40:54 -05:00
& format! ( " OUT > evalsproles {:?} " , & evalsproles ) ,
Some ( " IdentityManager > getspecialuserroles() " . to_string ( ) ) ,
None ,
) ;
2024-02-13 19:49:36 -05:00
2024-03-01 23:36:37 -05:00
// return evalsproles;
evalsproles
2024-01-31 21:30:08 -05:00
}
2024-01-29 06:18:27 -05:00
}
2024-02-19 21:04:01 -05:00
#[ cfg(test) ]
mod core_identity {
use casual_logger ::Extension ;
use super ::* ;
#[ test ]
fn user_role_identity ( ) {
Log ::set_file_ext ( Extension ::Log ) ;
// Log::set_level(Level::Trace);
// let result = 2 + 2;
// assert_eq!(result, 4);
2024-02-25 10:40:54 -05:00
assert_eq! (
UserRole ::SupMod ( ChType ::Channel ( " strong " . to_string ( ) ) ) ,
UserRole ::SupMod ( ChType ::Channel ( " Strong " . to_lowercase ( ) ) )
) ;
}
2024-02-19 21:04:01 -05:00
#[ tokio::test ]
async fn promote_workflow_01 ( ) {
Log ::set_file_ext ( Extension ::Log ) ;
// Log::set_level(Level::Trace);
2024-02-25 10:40:54 -05:00
2024-02-19 21:04:01 -05:00
let test_id_mgr = IdentityManager ::init ( ) ;
// [x] Mod Attempts to Promote User
let channel = Some ( ChType ::Channel ( " twitchchanneltest " . to_string ( ) ) ) ;
let trgchatter = " regularChatter " . to_string ( ) ;
let authorizer_badge = & Some ( ChatBadge ::Mod ) ;
let authorizer = " chatMod " . to_string ( ) ;
let trg_role = None ;
2024-02-25 10:40:54 -05:00
let rslt = test_id_mgr
. promote (
authorizer ,
authorizer_badge ,
trgchatter . clone ( ) ,
channel . clone ( ) ,
trg_role ,
)
. await ;
assert_eq! (
rslt ,
ChangeResult ::Failed ( String ::from ( " You're not permitted to do that " ) )
) ;
}
2024-02-19 21:04:01 -05:00
#[ tokio::test ]
async fn promote_workflow_02 ( ) {
Log ::set_file_ext ( Extension ::Log ) ;
// Log::set_level(Level::Trace);
2024-02-25 10:40:54 -05:00
2024-02-19 21:04:01 -05:00
let test_id_mgr = IdentityManager ::init ( ) ;
// [x] Broadcaster Promotes Chatter to SupMod
let channel = Some ( ChType ::Channel ( " broadcasterer " . to_string ( ) ) ) ;
let trgchatter = " regularChatter " . to_string ( ) ;
let authorizer_badge = & Some ( ChatBadge ::Broadcaster ) ;
let authorizer = " broadcasterer " . to_string ( ) ;
let trg_role = None ;
2024-02-25 10:40:54 -05:00
let rslt = test_id_mgr
. promote (
authorizer . clone ( ) ,
authorizer_badge ,
trgchatter . clone ( ) ,
channel . clone ( ) ,
trg_role . clone ( ) ,
)
. await ;
assert_eq! (
rslt ,
ChangeResult ::Success ( " Promotion Successful " . to_string ( ) )
) ;
let rslt = test_id_mgr
. getspecialuserroles ( trgchatter . clone ( ) , channel . clone ( ) )
. await ;
2024-02-19 21:04:01 -05:00
assert! ( rslt . contains ( & UserRole ::Mod ( ChType ::Channel ( " broadcasterer " . to_string ( ) ) ) ) ) ;
2024-02-25 10:40:54 -05:00
let rslt = test_id_mgr
. promote (
authorizer . clone ( ) ,
authorizer_badge ,
trgchatter . clone ( ) ,
channel . clone ( ) ,
trg_role . clone ( ) ,
)
. await ;
assert_eq! (
rslt ,
ChangeResult ::Success ( " Promotion Successful " . to_string ( ) )
) ;
let rslt = test_id_mgr
. getspecialuserroles ( trgchatter . clone ( ) , channel . clone ( ) )
. await ;
assert! ( rslt . contains ( & UserRole ::SupMod ( ChType ::Channel (
" broadcasterer " . to_string ( )
) ) ) ) ;
let rslt = test_id_mgr
. promote (
authorizer . clone ( ) ,
authorizer_badge ,
trgchatter . clone ( ) ,
channel . clone ( ) ,
trg_role . clone ( ) ,
)
. await ;
assert_eq! (
rslt ,
ChangeResult ::Failed ( String ::from ( " Already highest available role " ) )
) ;
2024-02-19 21:04:01 -05:00
}
#[ tokio::test ]
async fn promote_workflow_03 ( ) {
Log ::set_file_ext ( Extension ::Log ) ;
// Log::set_level(Level::Trace);
2024-02-25 10:40:54 -05:00
2024-02-19 21:04:01 -05:00
let test_id_mgr = IdentityManager ::init ( ) ;
// [x] SupMod Promotes Chatter to SupMod
// [x] Broadcaster first promotes a SupMod
2024-02-25 10:40:54 -05:00
2024-02-19 21:04:01 -05:00
let broadcaster = " broadcasterer " . to_string ( ) ;
let broadcaster_badge = & Some ( ChatBadge ::Broadcaster ) ;
let channel = Some ( ChType ::Channel ( broadcaster . clone ( ) ) ) ;
let supchatter = " superModerator " . to_string ( ) ;
let trg_role = None ;
2024-02-25 10:40:54 -05:00
let rslt = test_id_mgr
. promote (
broadcaster . clone ( ) ,
broadcaster_badge ,
supchatter . clone ( ) ,
channel . clone ( ) ,
trg_role . clone ( ) ,
)
. await ;
assert_eq! (
rslt ,
ChangeResult ::Success ( " Promotion Successful " . to_string ( ) )
) ;
let rslt = test_id_mgr
. promote (
broadcaster . clone ( ) ,
broadcaster_badge ,
supchatter . clone ( ) ,
channel . clone ( ) ,
trg_role . clone ( ) ,
)
. await ;
assert_eq! (
rslt ,
ChangeResult ::Success ( " Promotion Successful " . to_string ( ) )
) ;
let rslt = test_id_mgr
. getspecialuserroles ( supchatter . clone ( ) , channel . clone ( ) )
. await ;
2024-02-19 21:04:01 -05:00
assert! ( rslt . contains ( & UserRole ::SupMod ( channel . unwrap ( ) ) ) ) ;
// [x] SupMod Attempts to Promote Chatter to SupMod
// let broadcaster = "broadcasterer".to_string();
let authorizer = supchatter ;
let authorizer_badge = & Some ( ChatBadge ::Broadcaster ) ;
let channel = Some ( ChType ::Channel ( broadcaster . clone ( ) ) ) ;
let trgchatter = " regularChatter " . to_string ( ) ;
let trg_role = None ;
2024-02-25 10:40:54 -05:00
let rslt = test_id_mgr
. promote (
authorizer . clone ( ) ,
authorizer_badge ,
trgchatter . clone ( ) ,
channel . clone ( ) ,
trg_role . clone ( ) ,
)
. await ;
assert_eq! (
rslt ,
ChangeResult ::Success ( " Promotion Successful " . to_string ( ) )
) ;
let rslt = test_id_mgr
. getspecialuserroles ( trgchatter . clone ( ) , channel . clone ( ) )
. await ;
2024-02-19 21:04:01 -05:00
// assert!(rslt.contains(&UserRole::Mod(ChType::Channel("broadcasterer".to_string()))));
assert! ( rslt . contains ( & UserRole ::Mod ( channel . clone ( ) . unwrap ( ) ) ) ) ;
2024-02-25 10:40:54 -05:00
let rslt = test_id_mgr
. promote (
authorizer . clone ( ) ,
authorizer_badge ,
trgchatter . clone ( ) ,
channel . clone ( ) ,
trg_role . clone ( ) ,
)
. await ;
2024-02-19 21:04:01 -05:00
// assert_eq!(rslt, ChangeResult::Success("Promotion Successful".to_string()));
2024-02-25 10:40:54 -05:00
assert_eq! (
rslt ,
ChangeResult ::Failed ( " You're not permitted to do that " . to_string ( ) )
) ;
}
2024-02-19 21:04:01 -05:00
#[ tokio::test ]
async fn promote_workflow_04 ( ) {
Log ::set_file_ext ( Extension ::Log ) ;
// Log::set_level(Level::Trace);
2024-02-25 10:40:54 -05:00
2024-02-19 21:04:01 -05:00
let test_id_mgr = IdentityManager ::init ( ) ;
// [x] BotAdmin Promotes Chatter to SupMod
// [x] Create BotAdmin first
let botadmin = " botadministrator " . to_string ( ) ;
let botadmin_badge = & None ;
test_id_mgr . affirm_chatter_in_db ( botadmin . clone ( ) ) . await ;
2024-02-25 10:40:54 -05:00
test_id_mgr
. add_role ( botadmin . clone ( ) , UserRole ::BotAdmin )
. await ;
2024-02-19 21:04:01 -05:00
2024-02-25 10:40:54 -05:00
let rslt = test_id_mgr
. getspecialuserroles ( botadmin . clone ( ) , None )
. await ;
2024-02-19 21:04:01 -05:00
2024-02-25 10:40:54 -05:00
assert! ( rslt . contains ( & UserRole ::BotAdmin ) ) ;
2024-02-19 21:04:01 -05:00
// [x] SupMod Attempts to Promote Chatter to SupMod
// let broadcaster = "broadcasterer".to_string();
let authorizer = botadmin ;
let authorizer_badge = botadmin_badge ;
let channel = Some ( ChType ::Channel ( " somechannel " . to_string ( ) ) ) ;
let trgchatter = " regularChatter " . to_string ( ) ;
let trg_role = None ;
2024-02-25 10:40:54 -05:00
let rslt = test_id_mgr
. promote (
authorizer . clone ( ) ,
authorizer_badge ,
trgchatter . clone ( ) ,
channel . clone ( ) ,
trg_role . clone ( ) ,
)
. await ;
assert_eq! (
rslt ,
ChangeResult ::Success ( " Promotion Successful " . to_string ( ) )
) ;
let rslt = test_id_mgr
. getspecialuserroles ( trgchatter . clone ( ) , channel . clone ( ) )
. await ;
2024-02-19 21:04:01 -05:00
assert! ( rslt . contains ( & UserRole ::Mod ( channel . clone ( ) . unwrap ( ) ) ) ) ;
2024-02-25 10:40:54 -05:00
let rslt = test_id_mgr
. promote (
authorizer . clone ( ) ,
authorizer_badge ,
trgchatter . clone ( ) ,
channel . clone ( ) ,
trg_role . clone ( ) ,
)
. await ;
2024-02-19 21:04:01 -05:00
// assert_eq!(rslt, ChangeResult::Success("Promotion Successful".to_string()));
2024-02-25 10:40:54 -05:00
assert_eq! (
rslt ,
ChangeResult ::Success ( " Promotion Successful " . to_string ( ) )
) ;
2024-02-19 21:04:01 -05:00
2024-02-25 10:40:54 -05:00
let rslt = test_id_mgr
. getspecialuserroles ( trgchatter . clone ( ) , channel . clone ( ) )
. await ;
2024-02-19 21:04:01 -05:00
assert! ( rslt . contains ( & UserRole ::SupMod ( channel . clone ( ) . unwrap ( ) ) ) ) ;
2024-02-25 10:40:54 -05:00
let rslt = test_id_mgr
. promote (
authorizer . clone ( ) ,
authorizer_badge ,
trgchatter . clone ( ) ,
channel . clone ( ) ,
trg_role . clone ( ) ,
)
. await ;
assert_eq! (
rslt ,
ChangeResult ::Failed ( String ::from ( " Already highest available role " ) )
) ;
}
2024-02-19 21:04:01 -05:00
#[ tokio::test ]
async fn demote_workflow_01 ( ) {
Log ::set_file_ext ( Extension ::Log ) ;
// Log::set_level(Level::Trace);
// [x] SupMod demotes a mod
// [x] create a SupMod first
2024-02-25 10:40:54 -05:00
2024-02-19 21:04:01 -05:00
let test_id_mgr = IdentityManager ::init ( ) ;
let supmod = " supmoder " . to_string ( ) ;
// let supmod_badge = &None;
let channel = Some ( ChType ::Channel ( " somechannel " . to_string ( ) ) ) ;
test_id_mgr . affirm_chatter_in_db ( supmod . clone ( ) ) . await ;
2024-02-25 10:40:54 -05:00
test_id_mgr
. add_role ( supmod . clone ( ) , UserRole ::SupMod ( channel . clone ( ) . unwrap ( ) ) )
. await ;
2024-02-19 21:04:01 -05:00
2024-02-25 10:40:54 -05:00
let rslt = test_id_mgr
. getspecialuserroles ( supmod . clone ( ) , channel . clone ( ) )
. await ;
2024-02-19 21:04:01 -05:00
assert! ( rslt . contains ( & UserRole ::SupMod ( channel . clone ( ) . unwrap ( ) ) ) ) ;
// [x] Create regular mod
let regmod = " moder " . to_string ( ) ;
// let supmod_badge = &None;
// let channel = Some(ChType::Channel("somechannel".to_string()));
test_id_mgr . affirm_chatter_in_db ( regmod . clone ( ) ) . await ;
2024-02-25 10:40:54 -05:00
test_id_mgr
. add_role ( regmod . clone ( ) , UserRole ::Mod ( channel . clone ( ) . unwrap ( ) ) )
. await ;
2024-02-19 21:04:01 -05:00
2024-02-25 10:40:54 -05:00
let rslt = test_id_mgr
. getspecialuserroles ( regmod . clone ( ) , channel . clone ( ) )
. await ;
2024-02-19 21:04:01 -05:00
assert! ( rslt . contains ( & UserRole ::Mod ( channel . clone ( ) . unwrap ( ) ) ) ) ;
// [x] Regular mod attempts to demote a supmod
let authorizer = regmod . clone ( ) ;
let authorizer_badge = & None ;
let trgchatter = supmod . clone ( ) ;
2024-02-25 10:40:54 -05:00
let rslt = test_id_mgr
. demote (
authorizer . clone ( ) ,
authorizer_badge ,
trgchatter . clone ( ) ,
channel . clone ( ) ,
)
. await ;
2024-02-19 21:04:01 -05:00
2024-02-25 10:40:54 -05:00
assert_eq! (
rslt ,
ChangeResult ::Failed ( " You're not permitted to do that " . to_string ( ) )
) ;
2024-02-19 21:04:01 -05:00
// [x] SupMod demotes regular mod
let authorizer = supmod ;
let authorizer_badge = & None ;
let trgchatter = regmod ;
2024-02-25 10:40:54 -05:00
let rslt = test_id_mgr
. demote (
authorizer . clone ( ) ,
authorizer_badge ,
trgchatter . clone ( ) ,
channel . clone ( ) ,
)
. await ;
assert_eq! (
rslt ,
ChangeResult ::Success ( " Demoted successfully " . to_string ( ) )
) ;
let rslt = test_id_mgr
. demote (
authorizer . clone ( ) ,
authorizer_badge ,
trgchatter . clone ( ) ,
channel . clone ( ) ,
)
. await ;
assert_eq! (
rslt ,
ChangeResult ::Failed (
" Target chatter does not have a role that can be demoted " . to_string ( )
)
) ;
2024-02-19 21:04:01 -05:00
}
}