Leagues support (#51)

* Completely opt in support via the new command `/set_leagues_channel`.  You should not get any Leagues broadcasts unless you have this set. This can be the same channel as your broadcast one
* On launch, we support Area Unlocks, Combat Masteries, and Relic announcements. The league's rank will be added later. You can also toggle each of these using the `/toggle` command
* Normal broadcasts on leagues world like drop logs will happen if you set `/set_leagues_channel` but be prefix letting you know it was a leagues drop. These will also follow the standard broadcast rules you have set.
* If there is enough interest, I will go back and personalize the messages and allow blocks for league tiers. Things like 1st area unlock.

Author: fatfingers23

justfile

@@ -0,0 +1,25 @@
+#Just file to build and release the docker image for production
+
+#Image names
+shuttle := "trackscape"
+worker := "trackscape-worker"
+cronWorker := "trackscape-cron-worker"
+dockerRepo := "fatfingers23"
+tag := "latest"
+
+#Build and release
+newRelease:
+    #Shuttle
+    docker build --platform linux/amd64 -t {{shuttle}} -f dockerfiles/Shuttle.Dockerfile .
+    docker tag {{shuttle}}:{{tag}} {{dockerRepo}}/{{shuttle}}:{{tag}}
+    docker push {{dockerRepo}}/{{shuttle}}:{{tag}}
+
+    #Worker
+    docker build --platform linux/amd64 -t {{worker}} -f dockerfiles/Worker.Dockerfile .
+    docker tag {{worker}}:{{tag}} {{dockerRepo}}/{{worker}}:{{tag}}
+    docker push {{dockerRepo}}/{{worker}}:{{tag}}
+
+    #Cron Worker
+    docker build --platform linux/amd64 -t {{cronWorker}} -f dockerfiles/CronWorker.Dockerfile .
+    docker tag {{cronWorker}}:{{tag}} {{dockerRepo}}/{{cronWorker}}:{{tag}}
+    docker push {{dockerRepo}}/{{cronWorker}}:{{tag}}

trackscape-discord-api/src/controllers/chat_controller.rs

@@ -3,7 +3,7 @@ use crate::{handler, ChatServerHandle};
 use actix_web::web::Data;
 use actix_web::{error, post, web, Error, HttpRequest, HttpResponse, Scope};
 use celery::Celery;
-use log::{error, info};
+use log::error;
 use serenity::all::{ChannelId, CreateEmbed, CreateEmbedAuthor};
 use serenity::builder::CreateMessage;
 use serenity::http::Http;
@@ -120,7 +120,7 @@ async fn new_clan_chats(
 
         if chat.is_league_world.is_some() {
             if chat.is_league_world.unwrap() {
-                info!("Broadcast from League World")
+                // info!("Broadcast from League World")
             }
         }
         //Checks to make sure the message has not already been process since multiple people could be submitting them
@@ -148,7 +148,8 @@ async fn new_clan_chats(
         }
 
         if registered_guild.clan_name.clone().unwrap() != chat.clan_name {
-            error!("Clan name does not match the clan name saved in the database");
+            //TODO may remove. it happens a lot assuming from ppl moving clans
+            // error!("Clan name does not match the clan name saved in the database");
             continue;
         }
 
@@ -242,7 +243,36 @@ async fn new_clan_chats(
         let possible_broadcast = handler.extract_message().await;
 
         match possible_broadcast {
-            None => {}
+            None => {
+                if league_world {
+                    let possible_leagues_message = handler.extract_leagues_message().await;
+                    if let Some(leagues_message) = possible_leagues_message {
+                        let mut broadcast_embed = CreateEmbed::new()
+                            .title(leagues_message.title.clone())
+                            .description(leagues_message.message.clone())
+                            .color(0x0000FF)
+                            .timestamp(right_now);
+                        match leagues_message.icon_url {
+                            None => {}
+                            Some(icon_url) => {
+                                broadcast_embed = broadcast_embed.image(icon_url);
+                            }
+                        }
+                        let broadcast_message = CreateMessage::new().embed(broadcast_embed);
+                        //Only send if theres a leagues channel
+                        if let Some(channel_to_send_broadcast) =
+                            registered_guild.leagues_broadcast_channel
+                        {
+                            let new_broad_cast = ChannelId::new(channel_to_send_broadcast)
+                                .send_message(&*discord_http_client, broadcast_message)
+                                .await;
+                            if let Err(e) = new_broad_cast {
+                                error!("Error sending broadcast: {:?}", e);
+                            }
+                        }
+                    }
+                }
+            }
             Some(broadcast) => {
                 let _ = mongodb
                     .broadcasts

trackscape-discord-bot/src/commands/set_leagues_broadcast_channel.rs

@@ -1,15 +1,15 @@
+use log::error;
 use serenity::all::{
     CommandDataOption, CommandDataOptionValue, CommandOptionType, CreateCommandOption,
 };
 use serenity::builder::{CreateCommand, CreateMessage};
 use serenity::client::Context;
 use serenity::model::channel::ChannelType;
 use serenity::model::prelude::Permissions;
-use std::any::Any;
 use tracing::info;
 use trackscape_discord_shared::database::BotMongoDb;
 
-pub fn _register() -> CreateCommand {
+pub fn register() -> CreateCommand {
     CreateCommand::new("set_leagues_channel")
         .description("Sets a channel to receive league broadcasts. This is off by default")
         .default_member_permissions(Permissions::MANAGE_GUILD)
@@ -32,10 +32,21 @@ pub async fn run(
     let option = options.get(0).expect("Expected Channel Id option");
 
     if let CommandDataOptionValue::Channel(channel) = option.value {
-        if channel.type_id() != ChannelType::Text.type_id() {
+        let possible_actual_channel = channel.to_channel(&ctx).await;
+        if possible_actual_channel.is_err() {
+            error!("Error getting channel: {:?}", possible_actual_channel.err());
+            return Some("Error getting channel".to_string());
+        }
+        let guild_channel = possible_actual_channel
+            .expect("Expected channel")
+            .guild()
+            .expect("Expected guild channel");
+
+        if guild_channel.kind != ChannelType::Text {
+            error!("Please select a text channel.");
             return Some("Please select a text channel.".to_string());
         }
-        info!("Channel: {:?}", channel);
+
         let saved_guild_query = db.guilds.get_by_guild_id(guild_id).await;
 
         return match saved_guild_query {

trackscape-discord-bot/src/commands/toggle_broadcasts_command.rs

@@ -85,13 +85,32 @@ pub fn register() -> CreateCommand {
                 BroadcastType::PersonalBest.to_string(),
                 BroadcastType::PersonalBest.to_slug(),
             )
+            .add_string_choice(
+                BroadcastType::AreaUnlock.to_string(),
+                BroadcastType::AreaUnlock.to_slug(),
+            )
+            .add_string_choice(
+                BroadcastType::LeaguesRank.to_string(),
+                BroadcastType::LeaguesRank.to_slug(),
+            )
+            .add_string_choice(
+                BroadcastType::CombatMasteries.to_string(),
+                BroadcastType::CombatMasteries.to_slug(),
+            )
+            .add_string_choice(
+                BroadcastType::RelicTier.to_string(),
+                BroadcastType::RelicTier.to_slug(),
+            )
+            .required(true),
+        )
+        .add_option(
+            CreateCommandOption::new(
+                CommandOptionType::Boolean,
+                "toggle",
+                "Turns on(true) or off(false) the broadcast type.",
+            )
             .required(true),
         )
-        .add_option(CreateCommandOption::new(
-            CommandOptionType::Boolean,
-            "toggle",
-            "Turns on(true) or off(false) the broadcast type.",
-        ))
 }
 
 pub async fn run(

trackscape-discord-bot/src/main.rs

@@ -338,8 +338,7 @@ fn get_commands() -> Vec<CreateCommand> {
     commands.push(commands::expel_clanmate_command::register());
     commands.push(commands::name_change_command::register());
     commands.push(commands::manually_run_wom_sync_command::register());
-    //leagues didnt have any braodcasts this time around and over now
-    // commands.push(commands::set_leagues_broadcast_channel::register());
+    commands.push(commands::set_leagues_broadcast_channel::register());
     commands
 }
 pub async fn create_commands_for_guild(guild_id: &GuildId, ctx: Context) {

trackscape-discord-shared/src/osrs_broadcast_extractor.rs

@@ -257,6 +257,49 @@ pub mod osrs_broadcast_extractor {
         pub time_in_seconds: f64,
     }
 
+    //Leagues broadcasts
+    //TODO may come back and add more descriptive broadcasts for Leagues, but right now just going the "firehose" route
+    // #[derive(Clone, Debug, Serialize, Deserialize)]
+    // pub struct AreaUnlockBroadcast {
+    //     pub area: String,
+    //     pub player: String
+    // }
+
+    // #[derive(Clone, Debug, Serialize, Deserialize)]
+    // pub struct LeaguesRankBroadcast {
+    //     pub area: String,
+    //     pub player: String
+    // }
+
+    // #[derive(Clone, Debug, Serialize, Deserialize)]
+    // pub struct CombatMasteriesBroadcast {
+    //     pub player: String,
+    //     pub combat_mastery: String,
+    //     pub rank: i64,
+    // }
+    
+    #[derive(Clone, Debug, Serialize, Deserialize, PartialEq)]
+    pub enum LeaguesBroadCastType {
+        AreaUnlock,
+        LeaguesRank,
+        CombatMasteries,
+        RelicTier,
+        //Normal broadcast but for leagues, like drops
+        NormalBroadCast
+    }
+
+    impl LeaguesBroadCastType {
+        pub fn to_broadcast_type(&self) -> BroadcastType {
+            match self {
+                LeaguesBroadCastType::AreaUnlock => BroadcastType::AreaUnlock,
+                LeaguesBroadCastType::LeaguesRank => BroadcastType::LeaguesRank,
+                LeaguesBroadCastType::CombatMasteries => BroadcastType::CombatMasteries,
+                LeaguesBroadCastType::RelicTier => BroadcastType::RelicTier,
+                LeaguesBroadCastType::NormalBroadCast => BroadcastType::Unknown,
+            }
+        }
+    }
+
     #[derive(PartialEq, Deserialize, Serialize, Debug, Clone)]
     pub enum BroadcastType {
         ItemDrop,
@@ -274,7 +317,12 @@ pub mod osrs_broadcast_extractor {
         ExpelledFromClan,
         CofferDonation,
         CofferWithdrawal,
-        PersonalBest,
+        PersonalBest,        
+        //Leagues Broadcasts        
+        AreaUnlock,
+        LeaguesRank,
+        CombatMasteries,
+        RelicTier,
         Unknown,
     }
 
@@ -297,7 +345,12 @@ pub mod osrs_broadcast_extractor {
                 BroadcastType::ExpelledFromClan => "Expelled From Clan".to_string(),
                 BroadcastType::CofferDonation => "Coffer Donation".to_string(),
                 BroadcastType::CofferWithdrawal => "Coffer Withdrawal".to_string(),
-                BroadcastType::PersonalBest => "Personal Best".to_string(),
+                BroadcastType::PersonalBest => "Personal Best".to_string(),                
+                //Leagues Broadcasts
+                BroadcastType::AreaUnlock => "Area Unlock".to_string(),
+                BroadcastType::LeaguesRank => "Leagues Rank".to_string(),
+                BroadcastType::CombatMasteries => "Combat Masteries".to_string(),
+                BroadcastType::RelicTier => "Relic Tier".to_string(),
             }
         }
 
@@ -315,6 +368,11 @@ pub mod osrs_broadcast_extractor {
                 "Level Milestone" => BroadcastType::LevelMilestone,
                 "Collection Log" => BroadcastType::CollectionLog,
                 "Personal Best" => BroadcastType::PersonalBest,
+                //Leagues Broadcasts
+                "Area Unlock" => BroadcastType::AreaUnlock,
+                "Leagues Rank" => BroadcastType::LeaguesRank,
+                "Combat Masteries" => BroadcastType::CombatMasteries,
+                "Relic Tier" => BroadcastType::RelicTier,
                 _ => BroadcastType::Unknown,
             }
         }
@@ -338,6 +396,11 @@ pub mod osrs_broadcast_extractor {
                 BroadcastType::CofferDonation,
                 BroadcastType::CofferWithdrawal,
                 BroadcastType::PersonalBest,
+                //Leagues Broadcasts
+                BroadcastType::AreaUnlock,
+                BroadcastType::LeaguesRank,
+                BroadcastType::CombatMasteries,
+                BroadcastType::RelicTier,
             ]
         }
 
@@ -650,6 +713,23 @@ pub mod osrs_broadcast_extractor {
         }
     }
 
+    pub fn leagues_catch_all_broadcast_extractor(
+        message: String,
+    ) -> Option<LeaguesBroadCastType> {
+        if message.contains("has earned") && message.contains("Combat mastery") {
+            return Some(LeaguesBroadCastType::CombatMasteries);
+        }
+
+        if message.contains("has unlocked") && message.contains("League area") {
+            return Some(LeaguesBroadCastType::AreaUnlock);
+        }
+
+        if message.contains("has unlocked") && message.contains("League relic!") {
+            return Some(LeaguesBroadCastType::RelicTier);
+        }
+        None
+    }
+
     /// Parses a time string in the format of `HH:MM:SS` or `MM:SS` and returns the time in seconds
     pub fn osrs_time_parser(time: &str) -> f64 {
         let split_sub_second: Vec<&str> = time.split(".").collect();
@@ -826,6 +906,7 @@ mod tests {
         LevelMilestoneBroadcast, PersonalBestBroadcast, PetDropBroadcast, PkBroadcast,
         QuestCompletedBroadcast, XPMilestoneBroadcast,
     };
+    use osrs_broadcast_extractor::LeaguesBroadCastType;
     use rstest::rstest;
     use tracing::info;
 
@@ -1453,6 +1534,21 @@ mod tests {
         }
     }
 
+    #[test]
+    fn test_leagues_catch_all_broadcast_extractor() {
+        let test_leagues_catch_all = get_leagues_catch_all_broadcast_messages();
+        for test_leagues_catch_all in test_leagues_catch_all {
+            let possible_leagues_catch_all_extract =
+                osrs_broadcast_extractor::leagues_catch_all_broadcast_extractor(
+                    test_leagues_catch_all.message.clone(),
+                );
+            let leagues_catch_all = possible_leagues_catch_all_extract.unwrap();
+            info!("{:?}", leagues_catch_all);
+            assert_eq!(leagues_catch_all, test_leagues_catch_all.broadcast);
+        }
+    }
+
+
     #[rstest]
     #[case("0:56.40", 56.40)]
     #[case("1:25", 85.0)]
@@ -2302,4 +2398,27 @@ mod tests {
 
         messages
     }
+
+    fn get_leagues_catch_all_broadcast_messages() -> Vec<TestBroadcast<LeaguesBroadCastType>> {
+        let mut messages: Vec<TestBroadcast<LeaguesBroadCastType>> = Vec::new();
+
+        messages.push(TestBroadcast {
+            message: "RuneScape Player has earned their 6th Combat mastery point!".to_string(),
+            broadcast: LeaguesBroadCastType::CombatMasteries,
+        });
+
+        messages.push(TestBroadcast {
+            message: "RuneScape Player has unlocked their 3rd League area!".to_string(),
+            broadcast: LeaguesBroadCastType::AreaUnlock,
+        });
+
+        messages.push(TestBroadcast {
+            message: "RuneScape Player has unlocked their tier 3 League relic!".to_string(),
+            broadcast: LeaguesBroadCastType::RelicTier,
+        });
+
+        //TODO add rank as we find more examples
+
+        messages
+    }
 }