Updating runescape_bosses.json example config to follow new config style.

.gitignore

@@ -132,3 +132,5 @@ nextcord.log
 
 # data file for bot
 highscores_data.json
+highscores_message_map.json
+highscores_config.json

cogs/help/__init__.py

@@ -22,5 +22,5 @@ class HelpCog(commands.Cog):
 
 # setup functions for bot
 def setup(bot: commands.Bot):
-    """Adds functon to bot"""
+    """Adds function to bot"""
     bot.add_cog(HelpCog(bot))

cogs/message_listener/__init__.py

@@ -0,0 +1,48 @@
+"""
+Defines cog for on message listener.
+"""
+
+from nextcord.ext import commands
+import nextcord
+
+from highscores import submission_messages  # pylint: disable=import-error
+from highscores import highscores_data  # pylint: disable=import-error
+
+
+class SubmissionListener(commands.Cog, name="Message Listener"):
+    """Sets up message listener."""
+
+    def __init__(self, bot: commands.Bot):
+        self.bot = bot
+
+    @commands.Cog.listener()
+    async def on_message(self, proof_message: nextcord.Message):
+        """Listener for message creation. Adds score and attachments to submission."""
+        if proof_message.author.id in submission_messages:
+            message_id = submission_messages[proof_message.author.id]
+            submission_message: nextcord.Message = await self.bot.get_channel(
+                highscores_data["submission_channel_id"]
+            ).fetch_message(message_id)
+
+            # need check if correct user and correct channel
+            if proof_message.channel.id == highscores_data["submission_channel_id"]:
+
+                embed = submission_message.embeds[0]
+                if proof_message.content:
+                    embed.add_field(name="Score", value=proof_message.content, inline=False)
+                    await submission_message.edit(
+                        embed=embed,
+                    )
+                if len(proof_message.attachments) > 0:
+                    await submission_message.edit(
+                        files=[await attch.to_file() for attch in proof_message.attachments],
+                    )
+
+                await proof_message.delete()
+
+
+# This function will be called when this extension is loaded.
+# It is necessary to add these functions to the bot.
+def setup(bot: commands.Bot):
+    """Adds function to bot"""
+    bot.add_cog(SubmissionListener(bot))

cogs/post_highscores/__init__.py

@@ -3,10 +3,13 @@ Bot command to post the highscores
 """
 
 from nextcord.ext import commands
+import nextcord
+
+from cogs.submission.submission_views import SubmissionButton  # pylint: disable=import-error
 from highscores import highscores_config  # pylint: disable=import-error
 from highscores import highscores_data  # pylint: disable=import-error
-from utils import data_storage  # pylint: disable=import-error
+from utilities.data_storage import save_highscores_data  # pylint: disable=import-error
-from utils import highscore_message  # pylint: disable=import-error
+from utilities.utils import send_highscore_message  # pylint: disable=import-error
 
 
 class PostHighscores(commands.Cog, name="Post Highscores"):
@@ -16,6 +19,7 @@ class PostHighscores(commands.Cog, name="Post Highscores"):
         self.bot = bot
 
     @commands.command(name="post-scores")
+    @commands.has_permissions(administrator=True)
     async def post_highscores(self, ctx: commands.Context):
         """
         A command which posts the highscore in the designated channel.
@@ -25,22 +29,25 @@ class PostHighscores(commands.Cog, name="Post Highscores"):
         ?post-scores
         ```
         """
-        channel_id = highscores_data["channel_id"]
+        highscore_channel_id = highscores_data["highscore_channel_id"]
-        print(f"Printing out highscores information in channel {channel_id}")
+        print(f"Printing out highscores information in channel {highscore_channel_id}")
-        channel = self.bot.get_channel(channel_id)
+        channel = self.bot.get_channel(highscore_channel_id)
-        if channel is None:
-            response = 'Registered Highscores channel does not exist or was never registered. \
-                Register with "?register" command.'
-            await ctx.send(response)
-            return
-        for boss in highscores_config["bosses"]:
-            await highscore_message.send_highscore_message(channel, boss["boss"])
 
-        data_storage.save_highscores_data(highscores_data)
+        error_response = 'Registered Highscores channel does not exist or was never registered. \n\
+                Register with "?register" command.'
+        assert channel is not None, await ctx.send(error_response)
+
+        for boss, categories in highscores_config[  # pylint: disable=unused-variable
+            "highscore_table"
+        ].items():
+            message: nextcord.Message = await send_highscore_message(channel, boss)
+            await message.edit(view=SubmissionButton(self.bot))
+
+        save_highscores_data(highscores_data)
 
 
 # This function will be called when this extension is loaded.
 # It is necessary to add these functions to the bot.
 def setup(bot: commands.Bot):
-    """Adds functon to bot"""
+    """Adds function to bot"""
     bot.add_cog(PostHighscores(bot))

cogs/register/__init__.py

@@ -0,0 +1,67 @@
+"""
+Bot command for registering various channels to the bot.
+"""
+
+from nextcord import Embed
+from nextcord.ext import commands
+
+from highscores import highscores_data  # pylint: disable=import-error
+from utilities.data_storage import save_highscores_data  # pylint: disable=import-error
+
+
+class RegisterVerificationChannel(commands.Cog, name="Register"):
+    """Bot command for registering various channels to the bot."""
+
+    def __init__(self, bot: commands.Bot):
+        self.bot = bot
+
+    @commands.command(name="register")
+    @commands.has_permissions(administrator=True)
+    async def register_highscores(self, ctx: commands.Context, registration_type: str):
+        """A command which registers current channel as for various uses.
+        Usage:
+        ```
+        ?register verify (Use in channel you want to verify submissions in.)
+        ?register highscore (Use in channel you want to show highscore messages in.)
+        ?register submission (Use in channel you want submission messages to be send it.)
+        ?register help (Shows help message.)
+        ```
+        """
+        # respond to the message
+        channel_id = ctx.channel.id
+
+        if registration_type == "verify":
+            await ctx.send(f"Registered <#{channel_id}> as channel to post verifications in.")
+            highscores_data["verification_channel_id"] = channel_id
+        elif registration_type == "highscore":
+            await ctx.send(f"Registered <#{channel_id}> as channel to post highscores in.")
+            highscores_data["highscore_channel_id"] = channel_id
+        elif registration_type == "submission":
+            await ctx.send(f"Registered <#{channel_id}> as channel to post submissions in.")
+            highscores_data["submission_channel_id"] = channel_id
+        else:
+            embed = Embed(
+                title="Register command help", description="How to use the register command."
+            )
+            embed.add_field(
+                name="?register verify", value="Use in channel you want to verify submissions in."
+            )
+            embed.add_field(
+                name="?register highscore",
+                value="Use in channel you want to show highscore messages in.",
+            )
+            embed.add_field(
+                name="?register submission",
+                value="Use in channel you want submission messages to be send it.",
+            )
+            embed.add_field(name="?register help", value="Use to show this message.")
+            await ctx.reply(embed=embed)
+
+        save_highscores_data(highscores_data)
+
+
+# This function will be called when this extension is loaded.
+# It is necessary to add these functions to the bot.
+def setup(bot: commands.Bot):
+    """Adds function to bot"""
+    bot.add_cog(RegisterVerificationChannel(bot))

cogs/register_highscore_channel/__init__.py

@@ -1,35 +0,0 @@
-"""
-Bot command to register the highscores channel
-"""
-
-from nextcord.ext import commands
-from highscores import highscores_data  # pylint: disable=import-error
-from utils import data_storage  # pylint: disable=import-error
-
-
-class RegisterHighscoreChannel(commands.Cog, name="Register HighScore Channel"):
-    """Registers Highscore channel"""
-
-    def __init__(self, bot: commands.Bot):
-        self.bot = bot
-
-    @commands.command(name="register")
-    async def register_highscores(self, ctx: commands.Context):
-        """A command which registers current channel as channel to post highscores in.
-        Usage:
-        ```
-        ?register (in channel to post highscores in)
-        ```
-        """
-        print(f"Registering {ctx.channel.id}.")
-        # respond to the message
-        await ctx.send(f"Registered <#{ctx.channel.id}> as channel to post highscores in.")
-        highscores_data["channel_id"] = ctx.channel.id
-        data_storage.save_highscores_data(highscores_data)
-
-
-# This function will be called when this extension is loaded.
-# It is necessary to add these functions to the bot.
-def setup(bot: commands.Bot):
-    """Adds functon to bot"""
-    bot.add_cog(RegisterHighscoreChannel(bot))

cogs/score/__init__.py

@@ -3,17 +3,23 @@ Bot command to submit a score
 """
 
 from nextcord.ext import commands
-from utils import highscore_manage  # pylint: disable=import-error
 
-# from utils import highscore_manage  # pylint: disable=import-error
+from highscores import highscores_data  # pylint: disable=import-error
+from utilities.utils import submit_score  # pylint: disable=import-error
+from .verification_view import VerificationView
 
 
-class RegisterHighscoreChannel(commands.Cog, name="Score"):
+class Score(commands.Cog, name="Score"):
     """Submits a score."""
 
     def __init__(self, bot: commands.Bot):
         self.bot = bot
 
+    @commands.Cog.listener()
+    async def on_ready(self):
+        """Called when the cog is loaded"""
+        self.bot.add_view(VerificationView())
+
     @commands.command(name="score")
     async def score(self, ctx: commands.Context, boss_name: str, category: str, score: str):
         """A command which calls a function to submit the score to highscores.
@@ -21,13 +27,27 @@ class RegisterHighscoreChannel(commands.Cog, name="Score"):
         Usage:
         ```
         ?score "Boss Name" "Category" "score"
+        This command still works if you prefer to use it over the ui.
         ```
         """
-        await highscore_manage.submit_score(self, ctx, boss_name, category, score)
+        verification_channel_id = highscores_data["verification_channel_id"]
+        channel = self.bot.get_channel(verification_channel_id)
+
+        error_response = "Registered Verification channel does not exist or was never registered. \
+                Contact server admins."
+        assert channel is not None, await ctx.send(error_response)
+
+        verification_string = f"{ctx.author.display_name}:{boss_name}:{category}:{score}"
+
+        await channel.send(
+            content=verification_string,
+            files=[await attch.to_file() for attch in ctx.message.attachments],
+            view=VerificationView(),
+        )
 
 
 # This function will be called when this extension is loaded.
 # It is necessary to add these functions to the bot.
 def setup(bot: commands.Bot):
-    """Adds functon to bot"""
+    """Adds function to bot"""
-    bot.add_cog(RegisterHighscoreChannel(bot))
+    bot.add_cog(Score(bot))

cogs/score/verification_view.py

@@ -0,0 +1,40 @@
+"""View for verification buttons"""
+
+import nextcord
+from utilities.utils import submit_score  # pylint: disable=import-error
+
+
+class VerificationView(nextcord.ui.View):
+    """Defines views for verifying score submissions"""
+
+    def __init__(self):
+        super().__init__(timeout=None)
+
+    @nextcord.ui.button(
+        label="Approve", style=nextcord.ButtonStyle.green, custom_id="approve-score-command"
+    )
+    async def approve_button(
+        self, button: nextcord.ui.Button, interaction: nextcord.Interaction
+    ):  # pylint: disable=unused-argument
+        """Button for approving score submission."""
+        content = interaction.message.content.split(":")
+        user = content[0]
+        boss_name = content[1]
+        category = content[2]
+        score = content[3]
+
+        await submit_score(interaction, user, boss_name, category, score)
+        await interaction.message.delete()
+        await interaction.channel.send(
+            f"Approved: {boss_name} {category} {user} {score}",
+            files=[await attch.to_file() for attch in interaction.message.attachments],
+        )
+
+    @nextcord.ui.button(
+        label="Deny", style=nextcord.ButtonStyle.red, custom_id="deny-score-command"
+    )
+    async def deny_button(
+        self, button: nextcord.ui.Button, interaction: nextcord.Interaction
+    ):  # pylint: disable=unused-argument
+        """Button for denying score submission."""
+        await interaction.message.delete()

cogs/submission/__init__.py

@@ -0,0 +1,26 @@
+"""
+Cog for creating submission process.
+"""
+
+from nextcord.ext import commands
+
+from .submission_views import SubmissionButton
+
+
+class SubmissionCog(commands.Cog, name="Submission Cog"):
+    """Constructs submission method."""
+
+    def __init__(self, bot: commands.Bot):
+        self.bot = bot
+
+    @commands.Cog.listener()
+    async def on_ready(self):
+        """Called when cog is loaded"""
+        self.bot.add_view(SubmissionButton(self.bot))
+
+
+# This function will be called when this extension is loaded.
+# It is necessary to add these functions to the bot.
+def setup(bot: commands.Bot):
+    """Adds function to bot"""
+    bot.add_cog(SubmissionCog(bot))

cogs/submission/submission_views.py

@@ -0,0 +1,122 @@
+"""Views used for submission process."""
+
+from typing import Optional
+
+import nextcord
+from nextcord.ext import commands
+
+from utilities.data_storage import open_message_map  # pylint: disable=import-error
+from highscores import highscores_data  # pylint: disable=import-error
+from highscores import submission_messages  # pylint: disable=import-error
+from .verification_view import VerificationView
+
+
+class SubmissionButton(nextcord.ui.View):
+    """Defines view for score submission button."""
+
+    def __init__(self, bot: commands.Bot):
+        super().__init__(timeout=None)
+        self._bot = bot
+
+    @nextcord.ui.button(label="Submit", style=nextcord.ButtonStyle.primary, custom_id="submit")
+    async def submit_button(
+        self, button: nextcord.ui.Button, interaction: nextcord.Interaction
+    ):  # pylint: disable=unused-argument
+        """Button for score submission."""
+        highscores_message_map = open_message_map()
+        boss_name = highscores_message_map[str(interaction.message.id)]
+        embed = nextcord.Embed(title="Highscores Submission")
+        embed.add_field(name="Boss", value=boss_name, inline=False)
+        embed.add_field(name="User", value=interaction.user.display_name, inline=False)
+        channel = self._bot.get_channel(highscores_data["submission_channel_id"])
+        submission_message = await channel.send(
+            f"<@{interaction.user.id}>",
+            view=SubmissionDropdownView(
+                self._bot, interaction, await self._category_select_options(boss_name)
+            ),
+            embed=embed,
+        )
+
+        # a user should only have 1 submission active at once.
+        submission_messages[interaction.user.id] = submission_message.id
+
+    async def _category_select_options(self, boss_name: str) -> "list[nextcord.SelectOption]":
+        options: list[nextcord.SelectOption] = []  # pylint: disable=unsubscriptable-object
+        boss_dict = highscores_data[boss_name]
+        for category in boss_dict["categories"].items():
+            options.append(nextcord.SelectOption(label=category[0]))
+
+        return options
+
+
+class SubmissionDropdown(nextcord.ui.Select):
+    """Defines dropdown menu for submission"""
+
+    def __init__(
+        self,
+        bot: commands.Bot,
+        options: "list[nextcord.SelectOption]",
+    ):
+        super().__init__(
+            placeholder="Choose submission category.", min_values=1, max_values=1, options=options
+        )
+        self._bot = bot
+
+    async def callback(self, interaction: nextcord.Interaction):
+        embed = interaction.message.embeds[0]
+        embed.add_field(name="Category", value=self.values[0], inline=False)
+        await interaction.message.edit(
+            embed=embed,
+        )
+
+
+class SubmissionDropdownView(nextcord.ui.View):
+    """Defines submission dropdown process view"""
+
+    def __init__(
+        self,
+        bot: commands.Bot,
+        prev_interaction: nextcord.Interaction,
+        options: "list[nextcord.SelectOption]",
+        *,
+        timeout: Optional[float] = 180,
+    ):
+        super().__init__(timeout=timeout)
+        self.add_item(SubmissionDropdown(bot, options))
+        self._prev_interaction = prev_interaction
+        self.bot = bot
+
+    async def interaction_check(self, interaction: nextcord.Interaction) -> bool:
+        return self._prev_interaction.user == interaction.user
+
+    @nextcord.ui.button(
+        label="Submit Score", style=nextcord.ButtonStyle.green, custom_id="submit-score"
+    )
+    async def submit_button(
+        self, button: nextcord.ui.Button, interaction: nextcord.Interaction
+    ):  # pylint: disable=unused-argument
+        """Defines button to submit a user's score."""
+        verification_channel_id = highscores_data["verification_channel_id"]
+        channel = self.bot.get_channel(verification_channel_id)
+
+        error_response = "Registered Verification channel does not exist or was never registered. \
+                Contact server admins."
+        assert channel is not None, await channel.send(error_response)
+
+        await channel.send(
+            files=[await attch.to_file() for attch in interaction.message.attachments],
+            view=VerificationView(),
+            embed=interaction.message.embeds[0],
+        )
+        await interaction.message.edit(content=f"<@{interaction.user.id}> Submitted!", view=None)
+        submission_messages.pop(interaction.user.id)
+
+    @nextcord.ui.button(
+        label="Cancel", style=nextcord.ButtonStyle.red, custom_id="cancel-submission"
+    )
+    async def cancel_button(
+        self, button: nextcord.ui.Button, interaction: nextcord.Interaction
+    ):  # pylint: disable=unused-argument
+        """Deletes message to cancel interaction."""
+        submission_messages.pop(interaction.user.id)
+        await interaction.message.delete()

cogs/submission/verification_view.py

@@ -0,0 +1,46 @@
+"""View for verification buttons"""
+
+import nextcord
+from utilities.utils import submit_score  # pylint: disable=import-error
+
+
+class VerificationView(nextcord.ui.View):
+    """Defines views for verifying score submissions"""
+
+    def __init__(self):
+        super().__init__(timeout=None)
+
+    @nextcord.ui.button(
+        label="Approve", style=nextcord.ButtonStyle.green, custom_id="approve-button-submission"
+    )
+    async def approve_button(
+        self, button: nextcord.ui.Button, interaction: nextcord.Interaction
+    ):  # pylint: disable=unused-argument
+        """Button for approving score submission."""
+        content = interaction.message.embeds[0].to_dict()
+
+        for field in content["fields"]:
+            if field["name"] == "Boss":
+                boss_name = field["value"]
+            elif field["name"] == "Category":
+                category = field["value"]
+            elif field["name"] == "Score":
+                score = field["value"]
+            elif field["name"] == "User":
+                user = field["value"]
+
+        try:
+            await submit_score(interaction, user, boss_name, category, score)
+            await interaction.message.edit(f"Approved by <@{interaction.user.id}>.", view=None)
+        except UnboundLocalError:
+            await interaction.send("Instruct user to submit with all fields.")
+            await interaction.message.edit(view=None)
+
+    @nextcord.ui.button(
+        label="Deny", style=nextcord.ButtonStyle.red, custom_id="deny-button-submission"
+    )
+    async def deny_button(
+        self, button: nextcord.ui.Button, interaction: nextcord.Interaction
+    ):  # pylint: disable=unused-argument
+        """Button for denying score submission."""
+        await interaction.message.delete()

example_config/runescape_bosses.json

@@ -0,0 +1,844 @@
+{
+    "highscore_table": {
+        "The Ambassador": {
+            "Kill Count": {
+                "ascending": false,
+                "is_time_record": false
+            },
+            "Kill Time": {
+                "ascending": true,
+                "is_time_record": true
+            },
+            "Group Kill Count": {
+                "ascending": false,
+                "is_time_record": false
+            },
+            "Group Kill Time": {
+                "ascending": true,
+                "is_time_record": true
+            },
+            "Spooned Log": {
+                "ascending": true,
+                "is_time_record": false
+            }
+        },
+        "Araxxi": {
+            "Kill Count": {
+                "ascending": false,
+                "is_time_record": false
+            },
+            "Kill Time": {
+                "ascending": true,
+                "is_time_record": true
+            },
+            "Spooned Log": {
+                "ascending": true,
+                "is_time_record": false
+            }
+        },
+        "Arch-Glacor": {
+            "Kill Count": {
+                "ascending": false,
+                "is_time_record": false
+            },
+            "Kill Time": {
+                "ascending": true,
+                "is_time_record": true
+            },
+            "Hardmode Kill Count": {
+                "ascending": false,
+                "is_time_record": false
+            },
+            "Hardmode Kill Time": {
+                "ascending": true,
+                "is_time_record": true
+            },
+            "Enrage": {
+                "ascending": false,
+                "is_time_record": false
+            },
+            "Spooned Log": {
+                "ascending": true,
+                "is_time_record": false
+            }
+        },
+        "Astellarn": {
+            "Kill Count": {
+                "ascending": false,
+                "is_time_record": false
+            },
+            "Kill Time": {
+                "ascending": true,
+                "is_time_record": true
+            },
+            "Group Kill Count": {
+                "ascending": false,
+                "is_time_record": false
+            },
+            "Group Kill Time": {
+                "ascending": true,
+                "is_time_record": true
+            },
+            "Spooned Log": {
+                "ascending": true,
+                "is_time_record": false
+            }
+        },
+        "The Barrows Brothers": {
+            "Kill Count": {
+                "ascending": false,
+                "is_time_record": false
+            },
+            "Spooned Log": {
+                "ascending": true,
+                "is_time_record": false
+            }
+        },
+        "The Barrows: Rise of the Six": {
+            "Kill Count": {
+                "ascending": false,
+                "is_time_record": false
+            },
+            "Kill Time": {
+                "ascending": true,
+                "is_time_record": true
+            },
+            "Spooned Log": {
+                "ascending": true,
+                "is_time_record": false
+            }
+        },
+        "Beastmaster Durzag": {
+            "Kill Count": {
+                "ascending": false,
+                "is_time_record": false
+            },
+            "Kill Time": {
+                "ascending": true,
+                "is_time_record": true
+            },
+            "Spooned Log": {
+                "ascending": true,
+                "is_time_record": false
+            }
+        },
+        "Black Stone Dragon": {
+            "Kill Count": {
+                "ascending": false,
+                "is_time_record": false
+            },
+            "Kill Time": {
+                "ascending": true,
+                "is_time_record": true
+            },
+            "Group Kill Count": {
+                "ascending": false,
+                "is_time_record": false
+            },
+            "Group Kill Time": {
+                "ascending": true,
+                "is_time_record": true
+            },
+            "Spooned Log": {
+                "ascending": true,
+                "is_time_record": false
+            }
+        },
+        "Chaos Elemental": {
+            "Kill Count": {
+                "ascending": false,
+                "is_time_record": false
+            },
+            "Spooned Log": {
+                "ascending": true,
+                "is_time_record": false
+            }
+        },
+        "Commander Zilyana": {
+            "Kill Count": {
+                "ascending": false,
+                "is_time_record": false
+            },
+            "Kill Time": {
+                "ascending": true,
+                "is_time_record": true
+            },
+            "Hardmode Kill Count": {
+                "ascending": false,
+                "is_time_record": false
+            },
+            "Hardmode Kill Time": {
+                "ascending": true,
+                "is_time_record": true
+            },
+            "Spooned Log": {
+                "ascending": true,
+                "is_time_record": false
+            }
+        },
+        "Corporeal Beast": {
+            "Kill Count": {
+                "ascending": false,
+                "is_time_record": false
+            },
+            "Kill Time": {
+                "ascending": true,
+                "is_time_record": true
+            },
+            "Spooned Log": {
+                "ascending": true,
+                "is_time_record": false
+            }
+        },
+        "Crassian Leviathan": {
+            "Kill Count": {
+                "ascending": false,
+                "is_time_record": false
+            },
+            "Kill Time": {
+                "ascending": true,
+                "is_time_record": true
+            },
+            "Group Kill Count": {
+                "ascending": false,
+                "is_time_record": false
+            },
+            "Group Kill Time": {
+                "ascending": true,
+                "is_time_record": true
+            },
+            "Spooned Log": {
+                "ascending": true,
+                "is_time_record": false
+            }
+        },
+        "Croesus": {
+            "Kill Count": {
+                "ascending": false,
+                "is_time_record": false
+            },
+            "Kill Time": {
+                "ascending": true,
+                "is_time_record": true
+            },
+            "Spooned Log": {
+                "ascending": true,
+                "is_time_record": false
+            }
+        },
+        "Dagannoth Kings": {
+            "Kill Count": {
+                "ascending": false,
+                "is_time_record": false
+            },
+            "Spooned Log": {
+                "ascending": true,
+                "is_time_record": false
+            }
+        },
+        "General Graardor": {
+            "Kill Count": {
+                "ascending": false,
+                "is_time_record": false
+            },
+            "Kill Time": {
+                "ascending": true,
+                "is_time_record": true
+            },
+            "Hardmode Kill Count": {
+                "ascending": false,
+                "is_time_record": false
+            },
+            "Hardmode Kill Time": {
+                "ascending": true,
+                "is_time_record": true
+            },
+            "Spooned Log": {
+                "ascending": true,
+                "is_time_record": false
+            }
+        },
+        "Giant Mole": {
+            "Kill Count": {
+                "ascending": false,
+                "is_time_record": false
+            },
+            "Kill Time": {
+                "ascending": true,
+                "is_time_record": true
+            },
+            "Hardmode Kill Count": {
+                "ascending": false,
+                "is_time_record": false
+            },
+            "Hardmode Kill Time": {
+                "ascending": true,
+                "is_time_record": true
+            },
+            "Spooned Log": {
+                "ascending": true,
+                "is_time_record": false
+            }
+        },
+        "Gregorovic": {
+            "Kill Count": {
+                "ascending": false,
+                "is_time_record": false
+            },
+            "Kill Time": {
+                "ascending": true,
+                "is_time_record": true
+            },
+            "Hardmode Kill Count": {
+                "ascending": false,
+                "is_time_record": false
+            },
+            "Hardmode Kill Time": {
+                "ascending": true,
+                "is_time_record": true
+            },
+            "Spooned Log": {
+                "ascending": true,
+                "is_time_record": false
+            }
+        },
+        "Har-Aken": {
+            "Kill Count": {
+                "ascending": false,
+                "is_time_record": false
+            },
+            "Kill Time": {
+                "ascending": true,
+                "is_time_record": true
+            },
+            "Spooned Log": {
+                "ascending": true,
+                "is_time_record": false
+            }
+        },
+        "Helwyr": {
+            "Kill Count": {
+                "ascending": false,
+                "is_time_record": false
+            },
+            "Kill Time": {
+                "ascending": true,
+                "is_time_record": true
+            },
+            "Hardmode Kill Count": {
+                "ascending": false,
+                "is_time_record": false
+            },
+            "Hardmode Kill Time": {
+                "ascending": true,
+                "is_time_record": true
+            },
+            "Spooned Log": {
+                "ascending": true,
+                "is_time_record": false
+            }
+        },
+        "Kalphite King": {
+            "Kill Count": {
+                "ascending": false,
+                "is_time_record": false
+            },
+            "Kill Time": {
+                "ascending": true,
+                "is_time_record": true
+            },
+            "Spooned Log": {
+                "ascending": true,
+                "is_time_record": false
+            }
+        },
+        "Kalphite Queen": {
+            "Kill Count": {
+                "ascending": false,
+                "is_time_record": false
+            },
+            "Kill Time": {
+                "ascending": true,
+                "is_time_record": true
+            },
+            "Spooned Log": {
+                "ascending": true,
+                "is_time_record": false
+            }
+        },
+        "Kerapac": {
+            "Kill Count": {
+                "ascending": false,
+                "is_time_record": false
+            },
+            "Kill Time": {
+                "ascending": true,
+                "is_time_record": true
+            },
+            "Hardmode Kill Count": {
+                "ascending": false,
+                "is_time_record": false
+            },
+            "Hardmode Kill Time": {
+                "ascending": true,
+                "is_time_record": true
+            },
+            "Spooned Log": {
+                "ascending": true,
+                "is_time_record": false
+            }
+        },
+        "King Black Dragon": {
+            "Kill Count": {
+                "ascending": false,
+                "is_time_record": false
+            },
+            "Kill Time": {
+                "ascending": true,
+                "is_time_record": true
+            },
+            "Spooned Log": {
+                "ascending": true,
+                "is_time_record": false
+            }
+        },
+        "Kree'arra": {
+            "Kill Count": {
+                "ascending": false,
+                "is_time_record": false
+            },
+            "Kill Time": {
+                "ascending": true,
+                "is_time_record": true
+            },
+            "Hardmode Kill Count": {
+                "ascending": false,
+                "is_time_record": false
+            },
+            "Hardmode Kill Time": {
+                "ascending": true,
+                "is_time_record": true
+            },
+            "Spooned Log": {
+                "ascending": true,
+                "is_time_record": false
+            }
+        },
+        "K'ril Tsutsaroth": {
+            "Kill Count": {
+                "ascending": false,
+                "is_time_record": false
+            },
+            "Kill Time": {
+                "ascending": true,
+                "is_time_record": true
+            },
+            "Hardmode Kill Count": {
+                "ascending": false,
+                "is_time_record": false
+            },
+            "Hardmode Kill Time": {
+                "ascending": true,
+                "is_time_record": true
+            },
+            "Spooned Log": {
+                "ascending": true,
+                "is_time_record": false
+            }
+        },
+        "Legiones": {
+            "Kill Count": {
+                "ascending": false,
+                "is_time_record": false
+            },
+            "Kill Time": {
+                "ascending": true,
+                "is_time_record": true
+            },
+            "Spooned Log": {
+                "ascending": true,
+                "is_time_record": false
+            }
+        },
+        "The Magister": {
+            "Kill Count": {
+                "ascending": false,
+                "is_time_record": false
+            },
+            "Kill Time": {
+                "ascending": true,
+                "is_time_record": true
+            },
+            "Spooned Log": {
+                "ascending": true,
+                "is_time_record": false
+            }
+        },
+        "Masuta the Ascended": {
+            "Kill Count": {
+                "ascending": false,
+                "is_time_record": false
+            },
+            "Kill Time": {
+                "ascending": true,
+                "is_time_record": true
+            },
+            "Group Kill Count": {
+                "ascending": false,
+                "is_time_record": false
+            },
+            "Group Kill Time": {
+                "ascending": true,
+                "is_time_record": true
+            },
+            "Spooned Log": {
+                "ascending": true,
+                "is_time_record": false
+            }
+        },
+        "Nex": {
+            "Kill Count": {
+                "ascending": false,
+                "is_time_record": false
+            },
+            "Kill Time": {
+                "ascending": true,
+                "is_time_record": true
+            },
+            "Spooned Log": {
+                "ascending": true,
+                "is_time_record": false
+            }
+        },
+        "Nex - Angel of Death": {
+            "Kill Count": {
+                "ascending": false,
+                "is_time_record": false
+            },
+            "Kill Time": {
+                "ascending": true,
+                "is_time_record": true
+            },
+            "Spooned Log": {
+                "ascending": true,
+                "is_time_record": false
+            }
+        },
+        "Queen Black Dragon": {
+            "Kill Count": {
+                "ascending": false,
+                "is_time_record": false
+            },
+            "Kill Time": {
+                "ascending": true,
+                "is_time_record": true
+            },
+            "Spooned Log": {
+                "ascending": true,
+                "is_time_record": false
+            }
+        },
+        "Raksha": {
+            "Solo Kill Count": {
+                "ascending": false,
+                "is_time_record": false
+            },
+            "Solo Kill Time": {
+                "ascending": true,
+                "is_time_record": true
+            },
+            "Duo Kill Count": {
+                "ascending": false,
+                "is_time_record": false
+            },
+            "Duo Kill Time": {
+                "ascending": true,
+                "is_time_record": true
+            },
+            "Spooned Log": {
+                "ascending": true,
+                "is_time_record": false
+            }
+        },
+        "Rex Matriarchs": {
+            "Kill Count": {
+                "ascending": false,
+                "is_time_record": false
+            },
+            "Spooned Log": {
+                "ascending": true,
+                "is_time_record": false
+            }
+        },
+        "The Sanctum Guardian": {
+            "Kill Count": {
+                "ascending": false,
+                "is_time_record": false
+            },
+            "Kill Time": {
+                "ascending": true,
+                "is_time_record": true
+            },
+            "Group Kill Count": {
+                "ascending": false,
+                "is_time_record": false
+            },
+            "Group Kill Time": {
+                "ascending": true,
+                "is_time_record": true
+            },
+            "Spooned Log": {
+                "ascending": true,
+                "is_time_record": false
+            }
+        },
+        "Seiryu the Azure Serpent": {
+            "Kill Count": {
+                "ascending": false,
+                "is_time_record": false
+            },
+            "Kill Time": {
+                "ascending": true,
+                "is_time_record": true
+            },
+            "Group Kill Count": {
+                "ascending": false,
+                "is_time_record": false
+            },
+            "Group Kill Time": {
+                "ascending": true,
+                "is_time_record": true
+            },
+            "Spooned Log": {
+                "ascending": true,
+                "is_time_record": false
+            }
+        },
+        "Solak": {
+            "Kill Count": {
+                "ascending": false,
+                "is_time_record": false
+            },
+            "Kill Time": {
+                "ascending": true,
+                "is_time_record": true
+            },
+            "Spooned Log": {
+                "ascending": true,
+                "is_time_record": false
+            }
+        },
+        "Taraket the Necromancer": {
+            "Kill Count": {
+                "ascending": false,
+                "is_time_record": false
+            },
+            "Kill Time": {
+                "ascending": true,
+                "is_time_record": true
+            },
+            "Group Kill Count": {
+                "ascending": false,
+                "is_time_record": false
+            },
+            "Group Kill Time": {
+                "ascending": true,
+                "is_time_record": true
+            },
+            "Spooned Log": {
+                "ascending": true,
+                "is_time_record": false
+            }
+        },
+        "Telos": {
+            "Kill Count": {
+                "ascending": false,
+                "is_time_record": false
+            },
+            "Kill Time": {
+                "ascending": true,
+                "is_time_record": true
+            },
+            "Enrage": {
+                "ascending": false,
+                "is_time_record": false
+            },
+            "Spooned Log": {
+                "ascending": true,
+                "is_time_record": false
+            }
+        },
+        "The Twin Furies": {
+            "Kill Count": {
+                "ascending": false,
+                "is_time_record": false
+            },
+            "Kill Time": {
+                "ascending": true,
+                "is_time_record": true
+            },
+            "Hardmode Kill Count": {
+                "ascending": false,
+                "is_time_record": false
+            },
+            "Hardmode Kill Time": {
+                "ascending": true,
+                "is_time_record": true
+            },
+            "Spooned Log": {
+                "ascending": true,
+                "is_time_record": false
+            }
+        },
+        "TzKal-Zuk": {
+            "Kill Count": {
+                "ascending": false,
+                "is_time_record": false
+            },
+            "Kill Time": {
+                "ascending": true,
+                "is_time_record": true
+            },
+            "Hardmode Kill Count": {
+                "ascending": false,
+                "is_time_record": false
+            },
+            "Hardmode Kill Time": {
+                "ascending": true,
+                "is_time_record": true
+            },
+            "Spooned Log": {
+                "ascending": true,
+                "is_time_record": false
+            }
+        },
+        "TzTok-Jad": {
+            "Kill Count": {
+                "ascending": false,
+                "is_time_record": false
+            },
+            "Kill Time": {
+                "ascending": true,
+                "is_time_record": true
+            },
+            "Spooned Log": {
+                "ascending": true,
+                "is_time_record": false
+            }
+        },
+        "Verak Lith": {
+            "Kill Count": {
+                "ascending": false,
+                "is_time_record": false
+            },
+            "Kill Time": {
+                "ascending": true,
+                "is_time_record": true
+            },
+            "Group Kill Count": {
+                "ascending": false,
+                "is_time_record": false
+            },
+            "Group Kill Time": {
+                "ascending": true,
+                "is_time_record": true
+            },
+            "Spooned Log": {
+                "ascending": true,
+                "is_time_record": false
+            }
+        },
+        "Vindicta & Gorvek": {
+            "Kill Count": {
+                "ascending": false,
+                "is_time_record": false
+            },
+            "Kill Time": {
+                "ascending": true,
+                "is_time_record": true
+            },
+            "Hardmode Kill Count": {
+                "ascending": false,
+                "is_time_record": false
+            },
+            "Hardmode Kill Time": {
+                "ascending": true,
+                "is_time_record": true
+            },
+            "Spooned Log": {
+                "ascending": true,
+                "is_time_record": false
+            }
+        },
+        "Vorago": {
+            "Kill Count": {
+                "ascending": false,
+                "is_time_record": false
+            },
+            "Kill Time": {
+                "ascending": true,
+                "is_time_record": true
+            },
+            "Hardmode Kill Count": {
+                "ascending": false,
+                "is_time_record": false
+            },
+            "Hardmode Kill Time": {
+                "ascending": true,
+                "is_time_record": true
+            },
+            "Spooned Log": {
+                "ascending": true,
+                "is_time_record": false
+            }
+        },
+        "Yakamaru": {
+            "Kill Count": {
+                "ascending": false,
+                "is_time_record": false
+            },
+            "Kill Time": {
+                "ascending": true,
+                "is_time_record": true
+            },
+            "Spooned Log": {
+                "ascending": true,
+                "is_time_record": false
+            }
+        },
+        "Zamorak, Lord of Chaos (solo)": {
+            "Kill Count": {
+                "ascending": false,
+                "is_time_record": false
+            },
+            "Kill Time": {
+                "ascending": true,
+                "is_time_record": true
+            },
+            "Enrage": {
+                "ascending": false,
+                "is_time_record": false
+            },
+            "Spooned Log": {
+                "ascending": true,
+                "is_time_record": false
+            }
+        }
+        ,
+        "Zamorak, Lord of Chaos (group)": {
+            "Kill Count": {
+                "ascending": false,
+                "is_time_record": false
+            },
+            "Kill Time": {
+                "ascending": true,
+                "is_time_record": true
+            },
+            "Enrage": {
+                "ascending": false,
+                "is_time_record": false
+            }
+        }
+    },
+    "highscore_size": 3
+}

highscores.py

@@ -9,7 +9,9 @@ import nextcord
 from nextcord.ext import commands
 
 import config
-from utils import data_storage
+from utilities.data_storage import open_highscores_config
+from utilities.data_storage import open_highscores_data
+from utilities.data_storage import open_message_map
 
 logger = logging.getLogger("nextcord")
 logger.setLevel(logging.DEBUG)
@@ -18,8 +20,11 @@ handler.setFormatter(logging.Formatter("%(asctime)s:%(levelname)s:%(name)s: %(me
 logger.addHandler(handler)
 
 
-highscores_config = data_storage.open_highscores_config()
+highscores_config = open_highscores_config()
-highscores_data = data_storage.open_highscores_data()
+highscores_data = open_highscores_data()
+highscores_message_map = open_message_map()
+
+submission_messages: dict = {}
 
 
 def main():
@@ -29,7 +34,8 @@ def main():
     intents = nextcord.Intents.default()
 
     # Required in order to read messages (eg. prefix commands)
-    intents.message_content = True
+    intents.message_content = True  # pylint: disable=assigning-non-slot
+    intents.messages = True  # pylint: disable=assigning-non-slot
 
     # To enable the guilds priveleged intent:
     # intents.guilds = True

highscores_config.json

@@ -1,202 +0,0 @@
-{
-    "bosses": [
-        {
-            "boss": "The Ambassador",
-            "hardmode": true
-        },
-        {
-            "boss": "Araxxi",
-            "hardmode": false
-        },
-        {
-            "boss": "Arch-Glacor",
-            "hardmode": true
-        },
-        {
-            "boss": "Astellarn",
-            "hardmode": true
-        },
-        {
-            "boss": "The Barrows Brothers",
-            "hardmode": false
-        },
-        {
-            "boss": "The Barrows: Rise of the Six",
-            "hardmode": false
-        },
-        {
-            "boss": "Beastmaster Durzag",
-            "hardmode": false
-        },
-        {
-            "boss": "Black Stone Dragon",
-            "hardmode": true
-        },
-        {
-            "boss": "Chaos Elemental",
-            "hardmode": false
-        },
-        {
-            "boss": "Commander Zilyana",
-            "hardmode": true
-        },
-        {
-            "boss": "Corporeal Beast",
-            "hardmode": false
-        },
-        {
-            "boss": "Crassian Leviathan",
-            "hardmode": true
-        },
-        {
-            "boss": "Croesus",
-            "hardmode": false
-        },
-        {
-            "boss": "Dagannoth Kings",
-            "hardmode": false
-        },
-        {
-            "boss": "General Graardor",
-            "hardmode": true
-        },
-        {
-            "boss": "Giant Mole",
-            "hardmode": true
-        },
-        {
-            "boss": "Gregorovic",
-            "hardmode": true
-        },
-        {
-            "boss": "Har-Aken",
-            "hardmode": false
-        },
-        {
-            "boss": "Helwyr",
-            "hardmode": true
-        },
-        {
-            "boss": "Kalphite King",
-            "hardmode": false
-        },
-        {
-            "boss": "Kalphite Queen",
-            "hardmode": false
-        },
-        {
-            "boss": "Kerapac",
-            "hardmode": true
-        },
-        {
-            "boss": "King Black Dragon",
-            "hardmode": false
-        },
-        {
-            "boss": "Kree'arra",
-            "hardmode": true
-        },
-        {
-            "boss": "K'ril Tsutsaroth",
-            "hardmode": true
-        },
-        {
-            "boss": "Legiones",
-            "hardmode": false
-        },
-        {
-            "boss": "The Magister",
-            "hardmode": false
-        },
-        {
-            "boss": "Masuta the Ascended",
-            "hardmode": true
-        },
-        {
-            "boss": "Nex",
-            "hardmode": false
-        },
-        {
-            "boss": "Nex - Angel of Death",
-            "hardmode": false
-        },
-        {
-            "boss": "Queen Black Dragon",
-            "hardmode": false
-        },
-        {
-            "boss": "Raksha",
-            "hardmode": true
-        },
-        {
-            "boss": "Rex Matriarchs",
-            "hardmode": false
-        },
-        {
-            "boss": "The Sanctum Guardian",
-            "hardmode": true
-        },
-        {
-            "boss": "Seiryu the Azure Serpent",
-            "hardmode": true
-        },
-        {
-            "boss": "Solak",
-            "hardmode": false
-        },
-        {
-            "boss": "Taraket the Necromancer",
-            "hardmode": true
-        },
-        {
-            "boss": "Telos",
-            "hardmode": false
-        },
-        {
-            "boss": "The Twin Furies",
-            "hardmode": true
-        },
-        {
-            "boss": "TzKal-Zuk",
-            "hardmode": true
-        },
-        {
-            "boss": "TzTok-Jad",
-            "hardmode": false
-        },
-        {
-            "boss": "Verak Lith",
-            "hardmode": true
-        },
-        {
-            "boss": "Vindicta & Gorvek",
-            "hardmode": true
-        },
-        {
-            "boss": "Vorago",
-            "hardmode": true
-        },
-        {
-            "boss": "Yakamaru",
-            "hardmode": false
-        }
-    ],
-    "categories": {
-        "Kill Count": {
-            "hardmode": true,
-            "ascending": false,
-            "is_time_record": false
-        },
-        "Kill Time": {
-            "hardmode": true,
-            "ascending": true,
-            "is_time_record": true
-        },
-        "Spooned Log": {
-            "hardmode": false,
-            "ascending": true,
-            "is_time_record": false
-        }
-    },
-    "highscore_size": 3
-}

utilities/data_storage.py

@@ -0,0 +1,72 @@
+"""Functions for retreiving and storing highscores data and configurations."""
+
+import os
+import json
+
+HIGHSCORES_CONFIG_FILE = "highscores_config.json"
+HIGHSCORES_DATA_FILE = "highscores_data.json"
+HIGHSCORES_MESSAGE_MAP_FILE = "highscores_message_map.json"
+
+
+def open_highscores_config():
+    """
+    Opens the highscores config file and returns.
+    @return: dict of highscores config.
+    """
+    # Load bot config
+    with open(HIGHSCORES_CONFIG_FILE, encoding="utf-8", mode="r") as file:
+        return json.load(file)
+
+
+def open_highscores_data():
+    """
+    Opens a highscores_data.json file if one exists, otherwise creates a skeleton of the data.
+    @return: dict of highscores data.
+    """
+    if os.path.exists(HIGHSCORES_DATA_FILE):
+        with open(HIGHSCORES_DATA_FILE, encoding="utf-8", mode="r") as file:
+            data = json.load(file)
+    else:
+        # create the json object
+        data = {"highscore_channel_id": -1, "verification_channel_id": -1}
+        config: dict = open_highscores_config()
+        for boss, categories in config["highscore_table"].items():
+            data[boss] = {"message_id": 0}
+            boss_categories = {}
+            for category, category_config in categories.items():  # pylint: disable=unused-variable
+                rank_list = []
+                boss_categories[category] = rank_list
+            data[boss]["categories"] = boss_categories
+    return data
+
+
+def open_message_map():
+    """
+    Opens a highscore_message_map.json file if one exists. Otherwise returns empty dict.
+    @return: dict message_map of message to boss.
+    """
+    if os.path.exists(HIGHSCORES_MESSAGE_MAP_FILE):
+        with open(HIGHSCORES_MESSAGE_MAP_FILE, encoding="utf-8", mode="r") as file:
+            message_map = json.load(file)
+    else:
+        # create the json object
+        message_map = {}
+    return message_map
+
+
+def save_highscores_data(data):
+    """
+    Saves the highscores data dict into a json file.
+    @param data: dict of highscores data.
+    """
+    with open(HIGHSCORES_DATA_FILE, encoding="utf-8", mode="w") as file:
+        file.write(json.dumps(data, indent=4))
+
+
+def save_message_map(message_map):
+    """
+    Saves the highscores message mao data dict into a json file.
+    @param map: dict map of message to boss.
+    """
+    with open(HIGHSCORES_MESSAGE_MAP_FILE, encoding="utf-8", mode="w") as file:
+        file.write(json.dumps(message_map, indent=4))

utilities/utils.py

@@ -0,0 +1,151 @@
+"""
+Contains various utlity functions for highscores bot
+"""
+
+import nextcord
+from highscores import highscores_config  # pylint: disable=import-error
+from highscores import highscores_data  # pylint: disable=import-error
+from highscores import highscores_message_map  # pylint: disable=import-error
+from utilities.data_storage import save_highscores_data  # pylint: disable=import-error
+from utilities.data_storage import save_message_map  # pylint: disable=import-error
+
+
+def format_highscore_message(boss_name: str):
+    """
+    returns a formatted string for a boss's highscore
+    @param boss: the dictionary object for the boss
+    @return the formatted string
+    """
+    ret_string = f"**{boss_name}**\n```"
+    boss_data = highscores_data[boss_name]
+
+    # Gather all categories and add to string
+    for key, value in boss_data["categories"].items():
+        ret_string += f"{key}".ljust(25, " ")
+    ret_string += "\n"
+
+    highscore_size = highscores_config["highscore_size"]
+
+    # list rankings in a single line. Start with first place for each category and then continue
+    for i in range(highscore_size):
+        for key, value in boss_data["categories"].items():
+            if len(value) > i:
+                score = value[i]
+                ret_string += f"{i+1}: {score[0]} - {score[1]}".ljust(25, " ")
+            else:
+                ret_string += f"{i+1}: submit your score".ljust(25, " ")
+        ret_string += "\n"
+
+    return ret_string + "```"
+
+
+async def send_highscore_message(channel, boss_name: str) -> nextcord.Message:
+    """
+    Function takes care of checking if a message exists for a boss, then
+    creating and sending/editing the message
+    @param channel: the channel to send the message in/search for message id
+    @param boss: the boss to send the message about
+    """
+    highscore_string = format_highscore_message(boss_name)
+
+    message_id = highscores_data[boss_name]["message_id"]
+    try:
+        message: nextcord.Message = await channel.fetch_message(message_id)
+        await message.edit(content=highscore_string)
+    except nextcord.NotFound:
+        # message doesn't exist.
+        message: nextcord.Message = await channel.send(highscore_string)
+        message_id = message.id
+        highscores_data[boss_name]["message_id"] = message_id
+        # save message -> boss_name in message_map
+        highscores_message_map[str(message_id)] = boss_name
+        save_message_map(highscores_message_map)
+
+    return message
+
+
+async def submit_score(
+    interaction: nextcord.Interaction, user: str, boss_name: str, category: str, score: str
+):
+    """
+    Adds a score to the high scores and sorts. Removes a score if larger than size limit.
+    @param boss: the boss to add score to
+    @param category: the category to add score to
+    @param user: user who submitted score
+    @param score: score to add
+    """
+
+    boss_category_config = highscores_config["highscore_table"][boss_name][category]
+
+    # capping to 12 characters because runescape names are 12 characters long.
+    # Splitting on pipe. My discord has multiple names on account split by pipe.
+    user = user.split("|")[0][:12]
+
+    # strip leading zeros and colon from score
+    score = score.lstrip("0:")
+
+    # create score tuple for either time or int
+    # define sort index
+    if boss_category_config["is_time_record"]:
+        if score.find(":") == -1:
+            score_seconds = float(score)
+        else:
+            minutes = score.split(":")[0]
+            seconds = score.split(":")[1]
+            score_seconds = int(minutes) * 60 + float(seconds)
+        score_tuple = (user, score, score_seconds)
+        sort_index = 2
+
+    else:
+        score_tuple = (user, int(score))
+        sort_index = 1
+
+    scores: "list[tuple]" = highscores_data[boss_name]["categories"][category]
+
+    # if user is in an existing tuple, delete it.
+    users_scores: "list[tuple]" = [score_tuple]
+    for tup in scores:
+        if user == tup[0]:
+            # Add tup to users_scores, remove from scores
+            users_scores.append(tup)
+
+    # sort users_scores
+    users_scores.sort(
+        key=lambda x: x[sort_index],
+        reverse=not boss_category_config["ascending"],
+    )
+
+    for index, tup in enumerate(users_scores):
+        if index == 0:
+            # first score is the best score.
+            if tup not in scores:
+                scores.append(tup)
+        else:
+            # discard all other scores from scores list.
+            if tup in scores:
+                scores.remove(tup)
+
+    # sort scores.
+    scores.sort(
+        key=lambda x: x[sort_index],
+        reverse=not boss_category_config["ascending"],
+    )
+
+    # enforce highscore size
+    while len(scores) > highscores_config["highscore_size"]:
+        scores.pop()
+    highscores_data[boss_name]["categories"][category] = scores
+
+    # edit message
+    highscore_channel_id = highscores_data["highscore_channel_id"]
+    print(f"Editting message {highscore_channel_id}")
+    channel = interaction.guild.get_channel(highscore_channel_id)
+
+    error_response = 'Registered Highscores channel does not exist or was never registered. \
+            Register with "?register" command.'
+    assert channel is not None, await interaction.send(error_response, ephemeral=True)
+
+    await send_highscore_message(channel, boss_name)
+
+    # save data
+    save_highscores_data(highscores_data)

utils/data_storage.py

@@ -1,53 +0,0 @@
-"""
-Contains functions for saving and loading highscore data and configs.
-"""
-
-import json
-import os
-
-HIGHSCORES_CONFIG_FILE = "highscores_config.json"
-HIGHSCORES_DATA_FILE = "highscores_data.json"
-
-
-def open_highscores_data():
-    """
-    Opens a highscores_data.json file if one exists, otherwise creates a skeleton of the data.
-    @return: dict of highscores data.
-    """
-    if os.path.exists(HIGHSCORES_DATA_FILE):
-        with open(HIGHSCORES_DATA_FILE, encoding="utf-8", mode="r") as file:
-            data = json.load(file)
-    else:
-        # create the json object
-        data = {"channel_id": -1}
-        config = open_highscores_config()
-        for boss in config["bosses"]:
-            data[boss["boss"]] = {"message_id": 0}
-            boss_categories = {}
-            for key, value in config["categories"].items():
-                rank_list = []
-                boss_categories[key] = rank_list
-                if boss["hardmode"] and value["hardmode"]:
-                    rank_list = []
-                    boss_categories["Hardmode " + key] = rank_list
-            data[boss["boss"]]["categories"] = boss_categories
-    return data
-
-
-def open_highscores_config():
-    """
-    Opens the highscores config file and returns.
-    @return: dict of highscores config.
-    """
-    # Load bot config
-    with open(HIGHSCORES_CONFIG_FILE, encoding="utf-8", mode="r") as file:
-        return json.load(file)
-
-
-def save_highscores_data(data):
-    """
-    Saves the highscores data dict into a json file.
-    @param data: dict of highscores data.
-    """
-    with open(HIGHSCORES_DATA_FILE, encoding="utf-8", mode="w") as file:
-        file.write(json.dumps(data, indent=4))

utils/highscore_manage.py

@@ -1,60 +0,0 @@
-"""
-Contains various functions for managing the highscores data
-"""
-
-from nextcord.ext import commands
-from highscores import highscores_config  # pylint: disable=import-error
-from highscores import highscores_data  # pylint: disable=import-error
-from utils import highscore_message  # pylint: disable=import-error
-from utils import data_storage  # pylint: disable=import-error
-
-
-async def submit_score(self, ctx: commands.Context, boss_name: str, category: str, score: str):
-    """
-    Adds a score to the high scores and sorts. Removes a score if larger than size limit.
-    @param boss: the boss to add score to
-    @param category: the category to add score to
-    @param user: user who submitted score
-    @param score: score (int) to add
-    """
-    # TODO update user submission to not have dupe users
-
-    # create score tuple for either time or int
-    # define sort index
-    if highscores_config["categories"][category]["is_time_record"]:
-        score_list = score.split(":")
-        minutes = score_list[0]
-        seconds = score_list[1]
-        score_seconds = int(minutes) * 60 + int(seconds)
-        score_tuple = (ctx.author.display_name, score, score_seconds)
-        sort_index = 2
-
-    else:
-        score_tuple = (ctx.author.display_name, int(score))
-        sort_index = 1
-
-    scores = highscores_data[boss_name]["categories"][category]
-    scores.append(score_tuple)
-
-    # sort scores.
-    ascending = highscores_config["categories"][category]["ascending"]
-    scores.sort(key=lambda x: x[sort_index], reverse=not ascending)
-
-    # enforce highscore size
-    while len(scores) > highscores_config["highscore_size"]:
-        scores.pop()
-    highscores_data[boss_name]["categories"][category] = scores
-
-    # edit message
-    channel_id = highscores_data["channel_id"]
-    print(f"Editting message {channel_id}")
-    channel = self.bot.get_channel(channel_id)
-    if channel is None:
-        response = 'Registered Highscores channel does not exist or was never registered. \
-            Register with "?register" command.'
-        await ctx.send(response)
-        return
-    await highscore_message.send_highscore_message(channel, boss_name)
-
-    # save data
-    data_storage.save_highscores_data(highscores_data)

utils/highscore_message.py

@@ -1,56 +0,0 @@
-"""
-Contains various functions for sending/editing the highscore messages.
-"""
-
-import nextcord
-from highscores import highscores_config  # pylint: disable=import-error
-from highscores import highscores_data  # pylint: disable=import-error
-
-
-def format_highscore_message(boss_name: str):
-    """
-    returns a formatted string for a boss's highscore
-    @param boss: the dictionary object for the boss
-    @return the formatted string
-    """
-    ret_string = f"**{boss_name}**\n```"
-    boss_data = highscores_data[boss_name]
-
-    # Gather all categories and add to string
-    for key, value in boss_data["categories"].items():
-        ret_string += f"{key}".ljust(30, " ")
-    ret_string += "\n"
-
-    highscore_size = highscores_config["highscore_size"]
-
-    # list rankings in a single line. Start with first place for each category and then continue
-    for i in range(highscore_size):
-        for key, value in boss_data["categories"].items():
-            if len(value) > i:
-                score = value[i]
-                ret_string += f"{i+1}: {score[0]} - {score[1]}".ljust(30, " ")
-            else:
-                ret_string += f"{i+1}: submit your score".ljust(30, " ")
-        ret_string += "\n"
-
-    return ret_string + "```"
-
-
-async def send_highscore_message(channel, boss_name: str):
-    """
-    Function takes care of checking if a message exists for a boss, then
-    creating and sending/editing the message
-    @param channel: the channel to send the message in/search for message id
-    @param boss: the boss to send the message about
-    """
-    highscore_string = format_highscore_message(boss_name)
-
-    message_id = highscores_data[boss_name]["message_id"]
-    try:
-        message = await channel.fetch_message(message_id)
-        await message.edit(content=highscore_string)
-    except nextcord.NotFound:
-        # message doesn't exist.
-        message = await channel.send(highscore_string)
-        message_id = message.id
-        highscores_data[boss_name]["message_id"] = message_id