custom countdown

src/core/botmodules.rs

@@ -634,7 +634,7 @@ pub struct Routine {
     pub join_handle : Option<Arc<RwLock<JoinHandle<RoutineAR>>>> , 
     start_time : Option<DateTime<Local>> ,
     pub complete_iterations : i64 , 
-    remaining_iterations : Option<i64> ,
+    pub remaining_iterations : Option<i64> ,
     routine_attr : Vec<RoutineAttr> ,
     pub internal_signal : RoutineSignal ,
     pub self_routine_ar : Option<RoutineAR> ,

src/custom/experimental/experiment003.rs

@@ -16,6 +16,9 @@ const OF_CMD_CHANNEL:Channel = Channel(String::new());
 
 use casual_logger::Log;
 use rand::Rng;
+use rand::thread_rng;
+use rand::rngs::StdRng;
+use rand::seq::SliceRandom;
 use tokio::sync::RwLock;
 use std::borrow::Borrow;
 use std::sync::Arc;
@@ -50,9 +53,222 @@ pub async fn init(mgr: Arc<ModulesManager>) {
     botc1.add_to_modmgr(Arc::clone(&mgr)).await;
 
 
+    // 1. Define the BotAction
+    let botc1 = BotCommand {
+        module: BotModule(String::from("experiments003")),
+        command: String::from("countdown"), // command call name
+        alias: vec![], // String of alternative names
+        exec_body: actions_util::asyncbox(countdown_chnl_v1),
+        help: String::from("Test Command tester"),
+        required_roles: vec![
+            BotAdmin,
+            Mod(OF_CMD_CHANNEL),
+        ], 
+    };
+
+    // 2. Add the BotAction to ModulesManager
+    botc1.add_to_modmgr(Arc::clone(&mgr)).await;
+
+
+
 }
 
 
+async fn countdown_chnl_v1(params : ExecBodyParams) {
+
+    botlog::debug(
+        "[CHILDFN] countdown_chnl() triggered!",
+        Some("Experiments003 > countdown_chnl()".to_string()),
+        Some(&params.msg),
+    );
+
+
+    /*
+     create a fun countdown BotCommand that allows an Elevated Chatter to
+        -a add channels to target a routine message
+        -start to start the routine with an input String, that sends a number 
+            of messages to the targeted channels with a countdown, until it 
+            reaches 0 when it sends a cute or funny message
+
+        NOTE : At the moment, I don't have customizable persistence, so I would just use
+        counters from the Routine itself
+     */
+
+    /*
+        Because of some bot core features are not available, v1.0 of this could be : 
+        [x] 1. Create a Routine & start a routine
+        [x] 2. Have the routine go through each joined channel randomly and countdown
+        [x] 3. At the end, say "0, I love you uwu~" in the last chosen channel
+     */
+
+    /*
+        Usage  => 03.28 - skipping arguments as functinoality isn't enhanced
+
+        -a <channel> => 03.28 - Not sure if this is possible at the moment?
+
+        -start
+
+        -stop  => 03.28 - Not sure if this is possible at the moment?
+    
+     */
+
+    /*
+        [ ] Functional Use Case
+
+        1. -a <channel> adds targetted channels
+
+     */
+
+        // [-] Unwraps arguments from message
+
+        // let (arg1, arg2) = {
+
+        //     let mut argv = params.msg.message_text.split(' ');
+
+        //     argv.next(); // Skip the command name
+
+        //     let arg1 = argv.next();
+
+        //     let arg2 = argv.next();
+
+        //     (arg1, arg2)
+        // };
+
+
+
+    // [ ] 1. Create a Routine & start a routine
+
+    // let parentmodule = params.get_parent_module().await;
+    let module = params.get_module().await;
+    let channel = params.get_channel().await;
+    let routine_attr = vec![
+        RoutineAttr::RunOnce
+    ];
+    // let exec_body = actions_util::asyncbox(rtestbody);
+    let exec_body = actions_util::asyncbox(innertester); // <-- 03.27 - when below is uncommented, this is throwing an issue
+
+    async fn innertester(params : ExecBodyParams) {
+
+        
+
+        let logmsg_botact = match *params.curr_act.read().await {
+            BotAction::C(_) => "command",
+            BotAction::R(_) => "routine",
+            BotAction::L(_) => "listener",
+        } ;
+
+
+        botlog::trace(
+            format!("Params > Curr_act type : {:?}", logmsg_botact).as_str(),
+            Some("Experiments003  > countdown_chnl()".to_string()),
+            Some(&params.msg),
+        );
+        Log::flush();
+
+        let bot = Arc::clone(&params.bot);
+
+        let botlock = bot.read().await;
+        
+        if let BotAction::R(arr) = &*params.curr_act.read().await {
+
+            let iterleft = arr.read().await.remaining_iterations.unwrap_or(0);
+
+            // [ ] get joined channels
+            let joinedchannels = botlock.bot_channels.clone();
+
+
+            fn pick_a_channel(chnlvec : Vec<Channel>) -> Channel {
+                
+                // More Information : https://docs.rs/rand/0.7.2/rand/seq/trait.SliceRandom.html#tymethod.choose
+
+                let mut rng = thread_rng();
+                
+            // let joinedchannels = botlock.bot_channels.clone();
+                (*chnlvec.choose(&mut rng).unwrap()).clone()
+            }
+
+            let chosen_channel = pick_a_channel(joinedchannels);
+
+            let outmsg = if iterleft == 1 {
+                format!("{} I love you uwu~",iterleft)
+            } else { format!("{}",iterleft) };
+
+            botlock.botmgrs.chat
+            .say(
+                // joinedchannels.choose(&mut rng).unwrap().0.clone(), 
+                chosen_channel.0.clone(), 
+                outmsg, 
+                params.clone()
+            ).await;
+
+        }
+
+
+    }
+
+
+
+    // [ ] setup the routine
+    if let Ok(newr) = Routine::from(
+        "Routine Test".to_string(), 
+        module, 
+        channel.unwrap(), 
+        routine_attr,
+        exec_body, 
+        params.clone()
+    ).await {
+        let newr_ar = newr.clone();
+        // [ ] start the routine
+        if let Ok(_) = Routine::start(newr_ar.clone()).await {
+
+
+            botlog::debug(
+                "Successfully started",
+                Some("experiment003 > countdown_chnl()".to_string()),
+                Some(&params.msg),
+            );
+
+            
+            Log::flush();
+
+            let bot = Arc::clone(&params.bot);
+
+            let botlock = bot.read().await;
+
+            // uses chat.say_in_reply_to() for the bot controls for messages
+            botlock
+            .botmgrs
+            .chat
+            .say_in_reply_to(
+                &params.msg, 
+                "Started Routine!".to_string(),
+                params.clone()
+            ).await;
+
+    
+    
+        }
+
+
+    }
+
+
+    // botlock
+    // .botmgrs
+    // .chat
+    // .say_in_reply_to(
+    //     &params.msg, 
+    //     format!("{:?}",),
+    //     params.clone()
+    // ).await;
+
+
+
+}
+
+
+
+
 async fn test3_body(params : ExecBodyParams) {
     // println!("testy triggered!"); // NOTE : This test function intends to print (e.g., to stdout) at fn call
     botlog::debug(