Add submit button on group create.

commit 3627419e12
Merge: 2db744d 3446ce9
Author: alwayscompiling <[email protected]>
Date:   Tue Dec 6 22:36:51 2022 -0500

    Merge branch '45-sql-connection-timing-out' into develop

commit 3446ce9ca2
Author: alwayscompiling <[email protected]>
Date:   Tue Dec 6 22:27:05 2022 -0500

    Change session usage to on use basis.

commit 2db744d170
Author: alwayscompiling <[email protected]>
Date:   Sun Dec 4 21:44:54 2022 -0500

    Add restart policy.

commit fa33be1b4a
Author: alwayscompiling <[email protected]>
Date:   Sun Dec 4 21:25:57 2022 -0500

    Renamed docker compose file.

classes/submission.py

@@ -6,9 +6,10 @@ from enum import Enum
 
 from nextcord import Embed
 from sqlalchemy import select
+from sqlalchemy.orm import Session
 
 # pylint: disable=import-error
-from utilities.sql_alchemy_connection import Category, CategoryGroup, session
+from utilities.sql_data_classes import Category, CategoryGroup, engine
 
 
 class SubmissionState(Enum):
@@ -199,14 +200,15 @@ class Submission:
             .where(CategoryGroup.GuildId == self.guild_id)
             .where(CategoryGroup.GroupId == self.group_id)
         )
-        embed.add_field(name="Group", value=session.scalar(stmt), inline=False)
+        with Session(engine) as session:
-        if self.category_id:
+            embed.add_field(name="Group", value=session.scalar(stmt), inline=False)
-            stmt = (
+            if self.category_id:
-                select(Category.CategoryName)
+                stmt = (
-                .where(Category.GroupId == self.group_id)
+                    select(Category.CategoryName)
-                .where(Category.CategoryId == self.category_id)
+                    .where(Category.GroupId == self.group_id)
-            )
+                    .where(Category.CategoryId == self.category_id)
-            embed.add_field(name="Category", value=session.scalar(stmt), inline=False)
+                )
+                embed.add_field(name="Category", value=session.scalar(stmt), inline=False)
         if self.score:
             embed.add_field(name="Score", value=self.score, inline=False)
 

cogs/commands/__init__.py

@@ -4,10 +4,11 @@ Cog loader. Adds all command cogs to the bot.
 
 from nextcord.ext import commands
 
-# Command classes
+from .create import CreateCog
-from .data_management import DataManagementCog
+from .delete import DeleteCog
-from .message_management import MessageManagementCog
+from .refresh import RefreshCog
-from .settings_management import SettingsManagementCog
+from .set import SetCog
+from .update import UpdateCog
 
 
 # This function will be called when this extension is loaded.
@@ -16,6 +17,8 @@ def setup(bot: commands.Bot):
     """
     Adds all command classes to bot.
     """
-    bot.add_cog(DataManagementCog(bot))
+    bot.add_cog(CreateCog(bot))
-    bot.add_cog(MessageManagementCog(bot))
+    bot.add_cog(DeleteCog())
-    bot.add_cog(SettingsManagementCog())
+    bot.add_cog(RefreshCog(bot))
+    bot.add_cog(SetCog())
+    bot.add_cog(UpdateCog(bot))

cogs/commands/create.py

@@ -0,0 +1,172 @@
+"""
+Commands for creating items in bot.
+"""
+
+from typing import Optional
+
+import nextcord
+from nextcord.ext import commands
+from sqlalchemy import exc, select
+from sqlalchemy.orm import Session
+
+# pylint: disable=import-error
+from cogs.submission.submission_views import SubmissionCreateButton
+from utilities.sql_data_classes import Category, CategoryGroup, engine
+from utilities.utils import MAX_LINE_LENGTH, autofill_groups, send_highscore_message
+
+
+class CreateCog(commands.Cog, name="Create Cog"):
+    """
+    Class holds commands for creating things.
+    """
+
+    def __init__(self, bot: commands.Bot) -> None:
+        """
+        Default constructor for CreateCog class.
+        """
+        self._bot = bot
+
+    @nextcord.slash_command(default_member_permissions=nextcord.Permissions(administrator=True))
+    async def create(self, interaction: nextcord.Interaction):
+        """
+        Parent slash command for creating things. Never called.
+        """
+
+    # need all these arguments because discord command.
+    # pylint: disable=too-many-arguments
+    @create.subcommand(description="Create a new Category. Must not exist already in Group.")
+    async def category(
+        self,
+        interaction: nextcord.Interaction,
+        group_id: str = nextcord.SlashOption(name="group", description="Group to add Category to.", required=True),
+        category_name: str = nextcord.SlashOption(description="Name of new Category.", required=True),
+        is_ascending: bool = nextcord.SlashOption(description="If higher value is better score.", required=True),
+        is_time_record: bool = nextcord.SlashOption(
+            description="If the score should be shown in time format. Cannot be changed.", required=True
+        ),
+        is_validated: bool = nextcord.SlashOption(
+            description="If scores need to be validated before posted.", required=True
+        ),
+        size: int = nextcord.SlashOption(
+            description="How many scores to post in Category. Default is 3.", required=False, default=3, min_value=1
+        ),
+    ) -> None:
+        """
+        Creates a new category to be placed into group_id group. Fails if the category name already exists within the
+        group. Then calls send_highscore_message().
+
+        Args:
+            interaction (nextcord.Interaction): Interaction for the command.
+            group_id (str): Id of group to add category to. Is SlashOption.
+            category_name (str): Name of new category. Is SlashOption.
+            is_ascending (bool): If the scores are sorted ascending or not. Is SlashOption.
+            is_time_record (bool): If the scores are a time record or not. Is SlashOption.
+            is_validated (bool): If the scores should be validated or not. Is SlashOption.
+            size (int): How  many sores to show in the category message. Is SlashOption.
+        """
+
+        new_category = Category(
+            CategoryName=category_name,
+            GroupId=int(group_id),
+            Size=size,
+            IsAscending=is_ascending,
+            IsTimeRecord=is_time_record,
+            IsValidated=is_validated,
+        )
+
+        # Open connection to engine and add new category.
+        with Session(engine) as session:
+            stmt = select(CategoryGroup).where(CategoryGroup.GroupId == int(group_id))
+            group = session.scalar(stmt)
+            try:
+                session.add(new_category)
+                session.commit()
+                await send_highscore_message(session, interaction.guild, group)
+                await interaction.response.send_message(
+                    f'"{category_name}" has been added to "{group.GroupName}"!', ephemeral=True
+                )
+            except exc.IntegrityError:
+                # Category name already exists in group
+                session.rollback()
+                await interaction.response.send_message(
+                    f'"{category_name}" already exists in "{group.GroupName}". Please rename.', ephemeral=True
+                )
+
+    # need all these arguments because discord command.
+    # pylint: disable=too-many-arguments
+    @create.subcommand(description="Create a new Category Group. Must not exist already for Guild.")
+    async def group(
+        self,
+        interaction: nextcord.Interaction,
+        group_name: str = nextcord.SlashOption(description="Name of new Group.", required=True),
+        pad_length: int = nextcord.SlashOption(
+            description="Number of characters wide a category is printed. Default is 26.",
+            required=False,
+            default=26,
+            min_value=7,
+            max_value=MAX_LINE_LENGTH,
+        ),
+        username_length: int = nextcord.SlashOption(
+            description="Number of characters of a username to display. Default is 12.",
+            required=False,
+            default=12,
+            min_value=1,
+            max_value=30,
+        ),
+        channel: Optional[nextcord.abc.GuildChannel] = nextcord.SlashOption(
+            description="Channel to post Group in. If left empty, defaults to current channel.",
+            required=False,
+            channel_types=[nextcord.ChannelType.text],
+            default=None,
+        ),
+    ) -> None:
+        """
+        Creates a new category group to be placed into the database with the guild's id. Fails if the category group
+        name already exists within the guild. Then calls send_highscore_message().
+
+        Args:
+            interaction (nextcord.Interaction): Interaction for the command.
+            group_name (str): Name of new Group. Is SlashOption.
+            pad_length (int): Number of characters wide a category is printed. Is SlashOption.
+            username_length (int): Number of characters of a username to display. Is SlashOption.
+            channel (Optional[nextcord.abc.GuildChannel]): Channel to post group in. If None, defaults to current
+                channel. Is SlashOption.
+        """
+
+        # if no channel provided, use current channel.
+        if channel is None:
+            channel = interaction.channel
+
+        new_group = CategoryGroup(
+            GroupName=group_name,
+            ChannelId=channel.id,
+            GuildId=interaction.guild_id,
+            PadLength=pad_length,
+            UsernameLength=username_length,
+        )
+
+        with Session(engine) as session:
+            try:
+                session.add(new_group)
+                session.commit()
+                message: nextcord.Message = await send_highscore_message(session, interaction.guild, new_group)
+                await message.edit(view=SubmissionCreateButton(self._bot))
+                await interaction.response.send_message(f'"{group_name}" has been created!', ephemeral=True)
+            except exc.IntegrityError:
+                # Category Group already exists in guild
+                session.rollback()
+                await interaction.response.send_message(
+                    f'"{group_name}" already exists in "{interaction.guild.name}". Please rename.', ephemeral=True
+                )
+
+    @category.on_autocomplete("group_id")
+    async def group_autocomplete(self, interaction: nextcord.Interaction, group_id: str):
+        """
+        Collects list of table names and compares to input table name for autocomplete assistance.
+
+        Args:
+            interaction (nextcord.Interaction): Interaction with command.
+            group_id (str): String to run autocomplete compared to.
+        """
+
+        await interaction.response.send_autocomplete(autofill_groups(interaction.guild_id, group_id))

cogs/commands/data_management.py

@@ -1,241 +0,0 @@
-"""
-Commands for managing the tables/categories/scores for a Guild.
-"""
-
-from typing import Optional
-
-import nextcord
-from nextcord.ext import commands
-from sqlalchemy import distinct, select
-
-# pylint: disable=import-error
-from utilities.sql_alchemy_connection import Category, CategoryGroup, Guild, Score, session
-from utilities.utils import (
-    autofill_categories,
-    autofill_groups,
-    autofill_users_in_group_category,
-    autofill_users_in_guild,
-    send_highscore_message,
-)
-
-from .views.update_username_verify import UpdateUsernameVerifyView
-
-
-class DataManagementCog(commands.Cog, name="Table Management"):
-    """
-    Class holds commands for managing the data storage of the highscores.
-    """
-
-    def __init__(self, bot: commands.Bot):
-        """
-        Default constructor for DataManagement class. Sets internal bot variable.
-        """
-        self._bot: commands.Bot = bot
-
-    @commands.Cog.listener()
-    async def on_ready(self):
-        """
-        Called when cog is loaded. Adds views required for DataManagement commands.
-        """
-        self._bot.add_view(UpdateUsernameVerifyView())
-
-    @nextcord.slash_command(default_member_permissions=nextcord.Permissions(administrator=True))
-    async def delete(self, interaction: nextcord.Interaction):
-        """
-        Parent slash command for deleting things. Never called.
-        """
-
-    @delete.subcommand()
-    async def user(self, interaction: nextcord.Interaction):
-        """
-        Subcommand parent for deleting user information. Never called.
-        """
-
-    @user.subcommand(
-        description="Removes all of a user's scores. Warning: data is destroyed, use with case.",
-    )
-    async def from_all(
-        self,
-        interaction: nextcord.Interaction,
-        user_name: str = nextcord.SlashOption(
-            description="User to remove scores for. Note: This is not always a user's discord name.", required=True
-        ),
-    ):
-        """
-        Searches all of guild's scores data for any score from the user. Removes. Updates table
-        message is user was removed from that table.
-
-        Args:
-            interaction (nextcord.Interaction): Interaction that invoked the command.
-            user_name (str): User to remove from highscores
-        """
-
-        stmt = select(distinct(Score.CategoryId)).where(Score.UserName == user_name)
-        category_ids: "list[int]" = list(session.scalars(stmt))
-
-        stmt = select(Score).where(Score.UserName == user_name)
-        for score in session.scalars(stmt):
-            session.delete(score)
-        session.commit()
-
-        group_ids = select(Category.GroupId).where(Category.CategoryId.in_(category_ids))
-
-        stmt = select(CategoryGroup).where(CategoryGroup.GroupId.in_(group_ids))
-
-        for group in session.scalars(stmt):
-            await send_highscore_message(interaction.guild.get_channel(group.ChannelId), group)
-
-        await interaction.send(f'User "{user_name}" was removed from all tables.', ephemeral=True)
-
-    @user.subcommand(description="Deletes a user's scores from a category.")
-    async def from_category(
-        self,
-        interaction: nextcord.Interaction,
-        group_id: str = nextcord.SlashOption(name="group", description="Group to delete user from.", required=True),
-        category_id: str = nextcord.SlashOption(
-            name="category", description="Category to delete user from.", required=True
-        ),
-        user_name: str = nextcord.SlashOption(description="User to delete.", required=True),
-    ):
-        """
-        Removes a user from a category. Uses autofill functions to fill out group_id, category_id, and user_name.
-
-        Args:
-            interaction (nextcord.Interaction): Interaction that invoked the command.
-            group_id (str): String representation of Group id to remove user from. Is SlashOption.
-            category_id (str): String representation of Category id to remove user from. Is SlashOption.
-            user_name (str): The user to remove. Is SlashOption.
-        """
-
-        stmt = select(CategoryGroup).where(CategoryGroup.GroupId == int(group_id))
-        group = session.scalar(stmt)
-
-        stmt = select(Category.CategoryName).where(Category.CategoryId == int(category_id))
-        category_name = session.scalar(stmt)
-
-        stmt = select(Score).where(Score.CategoryId == int(category_id)).where(Score.UserName == user_name)
-
-        # there should only be one because category id and username are a composite primary key in score
-        session.delete(session.scalar(stmt))
-        session.commit()
-
-        await send_highscore_message(interaction.guild.get_channel(group.ChannelId), group)
-        await interaction.response.send_message(f'User "{user_name}" removed from "{category_name}".', ephemeral=True)
-
-    @user.subcommand(description="Deletes a user's scores from entire group.")
-    async def from_group(
-        self,
-        interaction: nextcord.Interaction,
-        group_id: str = nextcord.SlashOption(name="group", description="Group to delete user from.", required=True),
-        user_name: str = nextcord.SlashOption(description="User to delete.", required=True),
-    ):
-        """
-        Removes user from a goup. Uses autofill functions to fill out group_id and user_name.
-
-        Args:
-            interaction (nextcord.Interaction): Interaction that invoked the command.
-            group_id (str): String representation of Group id to remove user from. Is SlashOption.
-            user_name (str): The user to remove. Is SlashOption.
-        """
-
-        stmt = select(CategoryGroup).where(CategoryGroup.GroupId == int(group_id))
-        group = session.scalar(stmt)
-        category_ids = select(Category.CategoryId).where(Category.GroupId == int(group_id))
-        stmt = select(Score).where(Score.CategoryId.in_(category_ids)).where(Score.UserName == user_name)
-
-        for score in session.scalars(stmt):
-            session.delete(score)
-        session.commit()
-
-        await send_highscore_message(interaction.guild.get_channel(group.ChannelId), group)
-        await interaction.response.send_message(
-            f'User "{user_name}" removed from all categories in {group.GroupName}.', ephemeral=True
-        )
-
-    @from_category.on_autocomplete("group_id")
-    @from_group.on_autocomplete("group_id")
-    async def autocomplete_group(self, interaction: nextcord.Interaction, group_id: str):
-        """
-        Autocomplete function for table names.
-
-        Args:
-            interaction (nextcord.Interaction): Interaction that invoked the command.
-            group_id (str): String to be autocompleted with Group name.
-        """
-        await interaction.response.send_autocomplete(autofill_groups(interaction.guild_id, group_id))
-
-    @from_category.on_autocomplete("category_id")
-    async def autocomplete_category(self, interaction: nextcord.Interaction, category_id: str, group_id: str):
-        """
-        Autocomplete function for category names.
-
-        Args:
-            interaction (nextcord.Interaction): Interaction that invoked the command.
-            category_id (str): String to be autocompleted with Category name.
-            group_id (str): Group to find Category from.
-        """
-        await interaction.response.send_autocomplete(
-            autofill_categories(interaction.guild_id, int(group_id), category_id)
-        )
-
-    @from_category.on_autocomplete("user_name")
-    @from_group.on_autocomplete("user_name")
-    async def autocomplete_user(
-        self, interaction: nextcord.Interaction, user_name: str, group_id: str, category_id: Optional[str] = None
-    ):
-        """
-        Autocomplete functions for user names.
-
-        Args:
-            interaction (nextcord.Interaction): Interaction that invoked the command.
-            user_name (str): String to be autocompleted with User name.
-            group_id (str): String representation of Group id to find category from.
-            category_id (Optional[str]): String representation of Category id to find User from, can be None.
-        """
-
-        await interaction.response.send_autocomplete(
-            autofill_users_in_group_category(
-                interaction.guild_id, int(group_id), category_id if category_id else 0, user_name
-            )
-        )
-
-    @nextcord.slash_command(description="Request a username update. Admins must approve.")
-    async def update_username(
-        self,
-        interaction: nextcord.Interaction,
-        old_username: str = nextcord.SlashOption(description="Username currently stored in highscores.", required=True),
-        new_username: str = nextcord.SlashOption(description="Username to update to.", required=True),
-    ):
-        """
-        Creates a request to send to admins for changing a username. Uses
-        UpdateUsernameVerifyView to do the work.
-
-        Args:
-            interaction (nextcord.Interaction): Interaction that invoked the command
-            old_username (str): Username to replace.
-            new_username (str): Username to replace old with.
-        """
-        stmt = select(Guild.VerificationChannel).where(Guild.GuildId == interaction.guild_id)
-        verify_channel = interaction.guild.get_channel(session.scalar(stmt))
-
-        embed: nextcord.Embed = nextcord.Embed(title="Username change request.")
-        embed.add_field(name="Old Username", value=old_username)
-        embed.add_field(name="New Username", value=new_username)
-        await verify_channel.send(
-            content=f"Username change request from <@{interaction.user.id}>.",
-            embed=embed,
-            view=UpdateUsernameVerifyView(),
-        )
-        await interaction.send("Request sent to admins for verification.", ephemeral=True)
-
-    @update_username.on_autocomplete("old_username")
-    @from_all.on_autocomplete("user_name")
-    async def username_autofill(self, interaction: nextcord.Interaction, username: str):
-        """
-        Sends response from autofill_users_in_guild back to update_username for autocompletion of old_username.
-
-        Args:
-            interaction (nextcord.Interaction): Interaction with command.
-            old_username (str): String to run autocompletion against.
-        """
-        await interaction.response.send_autocomplete(autofill_users_in_guild(interaction.guild_id, username))

cogs/commands/delete.py

@@ -0,0 +1,297 @@
+"""
+Commands for deleting groups/categories/scores in database and messages in discord..
+"""
+
+from typing import Optional
+
+import nextcord
+from nextcord.ext import commands
+from sqlalchemy import distinct, select
+from sqlalchemy.orm import Session
+
+# pylint: disable=import-error
+from utilities.sql_data_classes import Category, CategoryGroup, Score, engine
+from utilities.utils import (
+    autofill_categories,
+    autofill_groups,
+    autofill_users_in_group_category,
+    autofill_users_in_guild,
+    send_highscore_message,
+)
+
+from .views.delete_confirm import DeleteConfirmView, create_delete_id
+
+
+class DeleteCog(commands.Cog, name="Table Management"):
+    """
+    Class holds commands for deleting.
+    """
+
+    def __init__(self) -> None:
+        """
+        Default constructor for DeleteCog class.
+        """
+
+    @nextcord.slash_command(default_member_permissions=nextcord.Permissions(administrator=True))
+    async def delete(self, interaction: nextcord.Interaction):
+        """
+        Parent slash command for deleting things. Never called.
+        """
+
+    @delete.subcommand()
+    async def all(self, interaction: nextcord.Interaction):
+        """
+        Subcommand parent for deleting all of a thing. Never called.
+        """
+
+    @all.subcommand(description="Clears highscores channel of all table messages. Does not change data.")
+    async def channel_messages(
+        self,
+        interaction: nextcord.Interaction,
+        channel: Optional[nextcord.abc.GuildChannel] = nextcord.SlashOption(
+            description="Channel to clear of messages.",
+            required=False,
+            channel_types=[nextcord.ChannelType.text],
+            default=None,
+        ),
+    ) -> None:
+        """
+        Deletes all group messages from channel. Does not change data.
+        Does not delete highscores channel id. Uses current channel if not supplied a channel.
+
+        Args:
+            interaction (nextcord.Interaction): Interaction that invoked the command
+            channel (Optional[nextcord.abc.GuildChannel]): Channel to clear of messages.
+                Is a SlashOption. Limited to text channels. Defaults to None.
+        """
+
+        if not channel:
+            channel = interaction.channel
+
+        with Session(engine) as session:
+            stmt = (
+                select(CategoryGroup)
+                .where(CategoryGroup.GuildId == interaction.guild_id)
+                .where(CategoryGroup.ChannelId == channel.id)
+            )
+            # TODO test when nothing in channel
+            groups = session.scalars(stmt)
+
+            await interaction.response.defer(ephemeral=True)
+
+            for group in groups:
+                try:
+                    table_message: nextcord.Message = await channel.fetch_message(group.MessageId)
+                    await table_message.delete()
+                except nextcord.NotFound:
+                    # silently ignore that messages are not found. They got deleted already.
+                    pass
+
+        await interaction.send("Table messages deleted.", ephemeral=True)
+
+    @all.subcommand(
+        description="Removes all of a user's scores. Warning: data is destroyed, use with case.",
+    )
+    async def users(
+        self,
+        interaction: nextcord.Interaction,
+        user_name: str = nextcord.SlashOption(
+            description="User to remove scores for. Note: This is not always a user's discord name.", required=True
+        ),
+    ):
+        """
+        Searches all of guild's scores data for any score from the user. Removes. Updates table
+        message is user was removed from that table.
+
+        Args:
+            interaction (nextcord.Interaction): Interaction that invoked the command.
+            user_name (str): User to remove from highscores
+        """
+
+        with Session(engine) as session:
+            stmt = select(distinct(Score.CategoryId)).where(Score.UserName == user_name)
+            category_ids: "list[int]" = list(session.scalars(stmt))
+
+            stmt = select(Score).where(Score.UserName == user_name)
+            for score in session.scalars(stmt):
+                session.delete(score)
+            session.commit()
+
+            group_ids = select(Category.GroupId).where(Category.CategoryId.in_(category_ids))
+
+            stmt = select(CategoryGroup).where(CategoryGroup.GroupId.in_(group_ids))
+
+            for group in session.scalars(stmt):
+                await send_highscore_message(session, interaction.guild, group)
+
+        await interaction.send(f'User "{user_name}" was removed from all tables.', ephemeral=True)
+
+    @delete.subcommand(description="Delete a category from a group. Deletion is perminant.")
+    async def category(
+        self,
+        interaction: nextcord.Interaction,
+        group_id: str = nextcord.SlashOption(name="group", description="Group to delete from.", required=True),
+        category_id: str = nextcord.SlashOption(name="category", description="Category to delete.", required=True),
+    ) -> None:
+        """
+        Calls the delete confirmation view for the given group and category.
+
+        Args:
+            interaction (nextcord.Interaction): Interaction of command.
+            group_id (str): Group to delete from. Is SlashOption.
+            category_id (str): Category to delete. Is SlashOption.
+        """
+        await interaction.response.send_modal(
+            DeleteConfirmView(custom_id=create_delete_id(int(group_id), int(category_id)))
+        )
+
+    @delete.subcommand(description="Delete a group. Deletion is perminant.")
+    async def group(
+        self,
+        interaction: nextcord.Interaction,
+        group_id: str = nextcord.SlashOption(name="group", description="Group to delete.", required=True),
+    ) -> None:
+        """
+        Calls the delete confirmation view for the given group.
+
+        Args:
+            interaction (nextcord.Interaction): Interaction of command.
+            group_id (str): Group to delete from. Is SlashOption.
+        """
+        await interaction.response.send_modal(DeleteConfirmView(custom_id=create_delete_id(int(group_id))))
+
+    @delete.subcommand()
+    async def user(self, interaction: nextcord.Interaction):
+        """
+        Subcommand parent for deleting user information. Never called.
+        """
+
+    @user.subcommand(description="Deletes a user's scores from a category.")
+    async def from_category(
+        self,
+        interaction: nextcord.Interaction,
+        group_id: str = nextcord.SlashOption(name="group", description="Group to delete user from.", required=True),
+        category_id: str = nextcord.SlashOption(
+            name="category", description="Category to delete user from.", required=True
+        ),
+        user_name: str = nextcord.SlashOption(description="User to delete.", required=True),
+    ):
+        """
+        Removes a user from a category. Uses autofill functions to fill out group_id, category_id, and user_name.
+
+        Args:
+            interaction (nextcord.Interaction): Interaction that invoked the command.
+            group_id (str): String representation of Group id to remove user from. Is SlashOption.
+            category_id (str): String representation of Category id to remove user from. Is SlashOption.
+            user_name (str): The user to remove. Is SlashOption.
+        """
+
+        with Session(engine) as session:
+            stmt = select(CategoryGroup).where(CategoryGroup.GroupId == int(group_id))
+            group = session.scalar(stmt)
+
+            stmt = select(Category.CategoryName).where(Category.CategoryId == int(category_id))
+            category_name = session.scalar(stmt)
+
+            stmt = select(Score).where(Score.CategoryId == int(category_id)).where(Score.UserName == user_name)
+
+            # there should only be one because category id and username are a composite primary key in score
+            session.delete(session.scalar(stmt))
+            session.commit()
+
+            await send_highscore_message(session, interaction.guild, group)
+            await interaction.response.send_message(
+                f'User "{user_name}" removed from "{category_name}".', ephemeral=True
+            )
+
+    @user.subcommand(description="Deletes a user's scores from entire group.")
+    async def from_group(
+        self,
+        interaction: nextcord.Interaction,
+        group_id: str = nextcord.SlashOption(name="group", description="Group to delete user from.", required=True),
+        user_name: str = nextcord.SlashOption(description="User to delete.", required=True),
+    ):
+        """
+        Removes user from a goup. Uses autofill functions to fill out group_id and user_name.
+
+        Args:
+            interaction (nextcord.Interaction): Interaction that invoked the command.
+            group_id (str): String representation of Group id to remove user from. Is SlashOption.
+            user_name (str): The user to remove. Is SlashOption.
+        """
+
+        with Session(engine) as session:
+            stmt = select(CategoryGroup).where(CategoryGroup.GroupId == int(group_id))
+            group = session.scalar(stmt)
+            category_ids = select(Category.CategoryId).where(Category.GroupId == int(group_id))
+            stmt = select(Score).where(Score.CategoryId.in_(category_ids)).where(Score.UserName == user_name)
+
+            for score in session.scalars(stmt):
+                session.delete(score)
+            session.commit()
+
+            await send_highscore_message(session, interaction.guild, group)
+            await interaction.response.send_message(
+                f'User "{user_name}" removed from all categories in {group.GroupName}.', ephemeral=True
+            )
+
+    @from_category.on_autocomplete("group_id")
+    @from_group.on_autocomplete("group_id")
+    @category.on_autocomplete("group_id")
+    @group.on_autocomplete("group_id")
+    async def group_autocomplete(self, interaction: nextcord.Interaction, group_id: str):
+        """
+        Autocomplete function for table names.
+
+        Args:
+            interaction (nextcord.Interaction): Interaction that invoked the command.
+            group_id (str): String to be autocompleted with Group name.
+        """
+        await interaction.response.send_autocomplete(autofill_groups(interaction.guild_id, group_id))
+
+    @from_category.on_autocomplete("category_id")
+    @category.on_autocomplete("category_id")
+    async def category_autocomplete(self, interaction: nextcord.Interaction, category_id: str, group_id: str):
+        """
+        Autocomplete function for category names.
+
+        Args:
+            interaction (nextcord.Interaction): Interaction that invoked the command.
+            category_id (str): String to be autocompleted with Category name.
+            group_id (str): Group to find Category from.
+        """
+        await interaction.response.send_autocomplete(
+            autofill_categories(interaction.guild_id, int(group_id), category_id)
+        )
+
+    @from_category.on_autocomplete("user_name")
+    @from_group.on_autocomplete("user_name")
+    async def user_autocomplete(
+        self, interaction: nextcord.Interaction, user_name: str, group_id: str, category_id: Optional[str] = None
+    ):
+        """
+        Autocomplete functions for user names.
+
+        Args:
+            interaction (nextcord.Interaction): Interaction that invoked the command.
+            user_name (str): String to be autocompleted with User name.
+            group_id (str): String representation of Group id to find category from.
+            category_id (Optional[str]): String representation of Category id to find User from, can be None.
+        """
+
+        await interaction.response.send_autocomplete(
+            autofill_users_in_group_category(
+                interaction.guild_id, int(group_id), category_id if category_id else 0, user_name
+            )
+        )
+
+    @users.on_autocomplete("user_name")
+    async def all_users_autocomplete(self, interaction: nextcord.Interaction, username: str):
+        """
+        Sends response from autofill_users_in_guild back to update_username for autocompletion of old_username.
+
+        Args:
+            interaction (nextcord.Interaction): Interaction with command.
+            old_username (str): String to run autocompletion against.
+        """
+        await interaction.response.send_autocomplete(autofill_users_in_guild(interaction.guild_id, username))

cogs/commands/message_management.py

@@ -1,152 +0,0 @@
-"""
-Commands for managing/displaying the highscores messages.
-"""
-
-from typing import Optional
-
-import nextcord
-from nextcord.ext import commands
-from sqlalchemy import select
-
-# pylint: disable=import-error
-from cogs.submission.submission_views import SubmissionCreateButton
-from utilities.sql_alchemy_connection import CategoryGroup, session
-from utilities.utils import autofill_groups, send_highscore_message
-
-
-class MessageManagementCog(commands.Cog, name="Message Management"):
-    """
-    Class holds commands for managing the messages that display highscores.
-    """
-
-    def __init__(self, bot: commands.Bot) -> None:
-        """
-        Default constructor for MessageManagement class
-
-        Args:
-            bot (commands.Bot): Bot object. Required to register submission button view.
-        """
-        self.bot = bot
-
-    @nextcord.slash_command(
-        description="Clears highscores channel of all table messages. Does not change data.",
-        default_member_permissions=nextcord.Permissions(administrator=True),
-    )
-    async def delete_channel_messages(
-        self,
-        interaction: nextcord.Interaction,
-        channel: Optional[nextcord.abc.GuildChannel] = nextcord.SlashOption(
-            description="Channel to clear of messages.",
-            required=False,
-            channel_types=[nextcord.ChannelType.text],
-            default=None,
-        ),
-    ) -> None:
-        """
-        Deletes all group messages from channel. Does not change data.
-        Does not delete highscores channel id. Uses current channel if not supplied a channel.
-
-        Args:
-            interaction (nextcord.Interaction): Interaction that invoked the command
-            channel (Optional[nextcord.abc.GuildChannel]): Channel to clear of messages.
-                Is a SlashOption. Limited to text channels. Defaults to None.
-        """
-
-        if not channel:
-            channel = interaction.channel
-
-        stmt = (
-            select(CategoryGroup)
-            .where(CategoryGroup.GuildId == interaction.guild_id)
-            .where(CategoryGroup.ChannelId == channel.id)
-        )
-        # TODO test when nothing in channel
-        groups = session.scalars(stmt)
-
-        await interaction.response.defer(ephemeral=True)
-
-        for group in groups:
-            try:
-                table_message: nextcord.Message = await channel.fetch_message(group.MessageId)
-                await table_message.delete()
-            except nextcord.NotFound:
-                # silently ignore that messages are not found. They got deleted already.
-                pass
-
-        await interaction.send("Table messages deleted.", ephemeral=True)
-
-    @nextcord.slash_command(
-        description="Triggers post/update of highscores to registered highscore channel.",
-        default_member_permissions=nextcord.Permissions(administrator=True),
-    )
-    async def post_highscore_groups(self, interaction: nextcord.Interaction) -> None:
-        """
-        A command which posts the highscore in the registered channel.
-        Sends warning if no channel has been registered.
-
-        Either creates new messages for each table if one doesn't exist
-        or edits the existing message.
-
-        Args:
-            interaction (nextcord.Interaction): Interaction that invoked the command.
-        """
-        stmt = select(CategoryGroup).where(CategoryGroup.GuildId == interaction.guild_id)
-
-        # awaiting response because posting scores takes a while
-        await interaction.response.defer(ephemeral=True)
-
-        for group in session.scalars(stmt):
-            channel = interaction.guild.get_channel(group.ChannelId)
-
-            # Error checking for registered highscore channel
-            error_response = "Registered Highscores channel does not exist or was never registered. "
-            error_response += 'Use "/register" to register channels.'
-            assert channel is not None, await interaction.response(error_response, ephemeral=True)
-
-            message: nextcord.Message = await send_highscore_message(channel, group)
-            await message.edit(view=SubmissionCreateButton(self.bot))
-
-        await interaction.send(f"Posted all groups in {interaction.guild.name}'s highscores.", ephemeral=True)
-
-    @nextcord.slash_command(
-        description="Manually refresh a table. Use when changing settings or data manually changed.",
-        default_member_permissions=nextcord.Permissions(administrator=True),
-    )
-    async def refresh_group(
-        self,
-        interaction: nextcord.Interaction,
-        group_id: str = nextcord.SlashOption(name="group", description="Name of Group.", required=True),
-    ) -> None:
-        """
-        Refreshes a table given by user.
-
-        Args:
-            interaction (nextcord.Interaction): Interaction that invoked the command.
-            group_id (str): Str representation of Group id to refresh. Is SlashOption.
-        """
-
-        stmt = (
-            select(CategoryGroup)
-            .where(CategoryGroup.GuildId == interaction.guild_id)
-            .where(CategoryGroup.GroupId == int(group_id))
-        )
-        group = session.scalar(stmt)
-
-        channel = interaction.guild.get_channel(group.ChannelId)
-
-        message: nextcord.Message = await send_highscore_message(channel, group)
-        await message.edit(view=SubmissionCreateButton(self.bot))
-
-        await interaction.response.send_message(f"Updated table {group.GroupName}!", ephemeral=True)
-
-    @refresh_group.on_autocomplete("group_id")
-    async def refresh_table_autofill(self, interaction: nextcord.Interaction, group_id: str):
-        """
-        Collects list of table names and compares to input table name for autocomplete assistance.
-
-        Args:
-            interaction (nextcord.Interaction): Interaction with command.
-            group_id (str): String to run autocomplete compared to.
-        """
-
-        await interaction.response.send_autocomplete(autofill_groups(interaction.guild_id, group_id))

cogs/commands/refresh.py

@@ -0,0 +1,104 @@
+"""
+Commands for refreshing highscore messages.
+"""
+
+import nextcord
+from nextcord.ext import commands
+from sqlalchemy import select
+from sqlalchemy.orm import Session
+
+# pylint: disable=import-error
+from cogs.submission.submission_views import SubmissionCreateButton
+from utilities.sql_data_classes import CategoryGroup, engine
+from utilities.utils import autofill_groups, send_highscore_message
+
+
+class RefreshCog(commands.Cog, name="Refresh Cog"):
+    """
+    Class holds commands for refreshing.
+    """
+
+    def __init__(self, bot: commands.Bot) -> None:
+        """
+        Default constructor for RefreshCog class
+
+        Args:
+            bot (commands.Bot): Bot object. Required to register submission button view.
+        """
+        self._bot = bot
+
+    @nextcord.slash_command(default_member_permissions=nextcord.Permissions(administrator=True))
+    async def refresh(self, interaction: nextcord.Interaction):
+        """
+        Parent slash command for refreshing things. Never called.
+        """
+
+    @refresh.subcommand(description="Manually refresh a table. Use when changing settings or data manually changed.")
+    async def group(
+        self,
+        interaction: nextcord.Interaction,
+        group_id: str = nextcord.SlashOption(name="group", description="Name of Group.", required=True),
+    ) -> None:
+        """
+        Refreshes a table given by user.
+
+        Args:
+            interaction (nextcord.Interaction): Interaction that invoked the command.
+            group_id (str): Str representation of Group id to refresh. Is SlashOption.
+        """
+
+        with Session(engine) as session:
+            stmt = (
+                select(CategoryGroup)
+                .where(CategoryGroup.GuildId == interaction.guild_id)
+                .where(CategoryGroup.GroupId == int(group_id))
+            )
+            group = session.scalar(stmt)
+
+            message: nextcord.Message = await send_highscore_message(session, interaction.guild, group)
+            await message.edit(view=SubmissionCreateButton(self._bot))
+
+            await interaction.response.send_message(f"Updated table {group.GroupName}!", ephemeral=True)
+
+    @refresh.subcommand()
+    async def all(self, interaction: nextcord.Interaction):
+        """
+        Subcommand parent for refreshing all things. Never called.
+        """
+
+    @all.subcommand(description="Triggers post/update of highscores to registered highscore channels.")
+    async def groups(self, interaction: nextcord.Interaction) -> None:
+        """
+        A command which posts the highscore in the registered channel.
+        Sends warning if no channel has been registered.
+
+        Either creates new messages for each table if one doesn't exist
+        or edits the existing message.
+
+        Args:
+            interaction (nextcord.Interaction): Interaction that invoked the command.
+        """
+
+        with Session(engine) as session:
+            stmt = select(CategoryGroup).where(CategoryGroup.GuildId == interaction.guild_id)
+
+            # awaiting response because posting scores takes a while
+            await interaction.response.defer(ephemeral=True)
+
+            for group in session.scalars(stmt):
+                message: nextcord.Message = await send_highscore_message(session, interaction.guild, group)
+                await message.edit(view=SubmissionCreateButton(self._bot))
+
+        await interaction.send(f"Posted all groups in {interaction.guild.name}'s highscores.", ephemeral=True)
+
+    @group.on_autocomplete("group_id")
+    async def group_autocomplete(self, interaction: nextcord.Interaction, group_id: str):
+        """
+        Collects list of table names and compares to input table name for autocomplete assistance.
+
+        Args:
+            interaction (nextcord.Interaction): Interaction with command.
+            group_id (str): String to run autocomplete compared to.
+        """
+
+        await interaction.response.send_autocomplete(autofill_groups(interaction.guild_id, group_id))

cogs/commands/set.py

@@ -1,5 +1,5 @@
 """
-Commands for managing the Guild's settings.
+Set command heirarchy.
 """
 
 from typing import Optional
@@ -7,29 +7,30 @@ from typing import Optional
 import nextcord
 from nextcord.ext import commands
 from sqlalchemy import select
+from sqlalchemy.orm import Session
 
 # pylint: disable=import-error
-from utilities.sql_alchemy_connection import CategoryGroup, Guild, session
+from utilities.sql_data_classes import CategoryGroup, Guild, engine
-from utilities.utils import autofill_groups
+from utilities.utils import MAX_LINE_LENGTH, autofill_groups
 
 
-class SettingsManagementCog(commands.Cog, name="Settings Management"):
+class SetCog(commands.Cog, name="Set command."):
     """
-    Class holds commands for managing Guild's settings.
+    Class holds commands for setting variables in guild's database.
     """
 
     def __init__(self) -> None:
         """
-        Default constructor for SettingsManagement class. Does nothing.
+        Default constructor for SetCog class. Does nothing.
         """
 
     @nextcord.slash_command(default_member_permissions=nextcord.Permissions(administrator=True))
-    async def register(self, interaction: nextcord.Interaction):
+    async def set(self, interaction: nextcord.Interaction):
         """
-        Parent slash command, never called.
+        Parent slash command for setting settings. Never called.
         """
 
-    @register.subcommand(description="Registers the channel for a Category Group's messages.")
+    @set.subcommand(description="Registers the channel for a Category Group's messages.")
     async def group_output_channel(
         self,
         interaction: nextcord.Interaction,
@@ -52,21 +53,62 @@ class SettingsManagementCog(commands.Cog, name="Settings Management"):
             channel (nextcord.abc.GuildChannel, optional): Channel to register
                 Is a SlashOption. Limited to text channels, Defaults to None.
         """
+
         if not channel:
             channel = interaction.channel
         channel_id = channel.id
-        stmt = (
+        with Session(engine) as session:
-            select(CategoryGroup)
+            stmt = (
-            .where(CategoryGroup.GuildId == interaction.guild_id)
+                select(CategoryGroup)
-            .where(CategoryGroup.GroupId == int(group_id))
+                .where(CategoryGroup.GuildId == interaction.guild_id)
-        )
+                .where(CategoryGroup.GroupId == int(group_id))
-        group = session.scalar(stmt)
+            )
-        group.ChannelId = channel_id
+            group = session.scalar(stmt)
-        session.commit()
+            group.ChannelId = channel_id
+            session.commit()
         await interaction.send(f"Registered <#{channel_id}>.", ephemeral=True)
 
-    @register.subcommand(description="Registers the channel for submission messages.")
+    @set.subcommand(
-    async def submission(
+        description="Set character length for a category. Can cut off username/score. Affects all categories."
+    )
+    async def pad_length(
+        self,
+        interaction: nextcord.Interaction,
+        group_id: str = nextcord.SlashOption(
+            name="group", description="Category Group to assign pad length to.", required=True
+        ),
+        length: int = nextcord.SlashOption(
+            description="Number of characters alloted to a category.",
+            required=True,
+            default=26,
+            min_value=7,
+            max_value=MAX_LINE_LENGTH,
+        ),
+    ) -> None:
+        """
+        Changes guild's category pad length.
+
+        Args:
+            interaction (nextcord.Interaction): Interaction that invoked the command
+            group_id (str): String representation of Group id to set pad length in. Is SlashOption.
+            length (int): Number of characters. Is SlashOption. Defaults to 26.
+        """
+
+        with Session(engine) as session:
+            stmt = (
+                select(CategoryGroup)
+                .where(CategoryGroup.GuildId == interaction.guild_id)
+                .where(CategoryGroup.GroupId == int(group_id))
+            )
+            group = session.scalar(stmt)
+            group.PadLength = length
+            session.commit()
+            await interaction.response.send_message(
+                f"Category pad length set to {length} for {group.GroupName}", ephemeral=True
+            )
+
+    @set.subcommand(description="Registers the channel for submission messages.")
+    async def submission_channel(
         self,
         interaction: nextcord.Interaction,
         channel: Optional[nextcord.abc.GuildChannel] = nextcord.SlashOption(
@@ -84,17 +126,50 @@ class SettingsManagementCog(commands.Cog, name="Settings Management"):
             channel Optional[nextcord.abc.GuildChannel], optional): Channel to register
                 Is a SlashOption. Limited to text channels, Defaults to None.
         """
+
         if not channel:
             channel = interaction.channel
-        channel_id = channel.id
+
-        stmt = select(Guild).where(Guild.GuildId == interaction.guild_id)
+        with Session(engine) as session:
-        guild = session.scalar(stmt)
+            channel_id = channel.id
-        guild.SubmissionChannel = channel_id
+            stmt = select(Guild).where(Guild.GuildId == interaction.guild_id)
-        session.commit()
+            guild = session.scalar(stmt)
+            guild.SubmissionChannel = channel_id
+            session.commit()
         await interaction.send(f"Registered <#{channel_id}>.", ephemeral=True)
 
-    @register.subcommand(description="Registers the channel for verification messages.")
+    @set.subcommand(description="Set username length for a Group of Categories.")
-    async def verify(
+    async def username_length(
+        self,
+        interaction: nextcord.Interaction,
+        group_id: str = nextcord.SlashOption(
+            name="group", description="Group to change username length of.", required=True
+        ),
+        length: int = nextcord.SlashOption(
+            description="Number of characters.", required=True, default=12, min_value=1, max_value=30
+        ),
+    ) -> None:
+        """
+        Changes guild's username length limit.
+
+        Args:
+            interaction (nextcord.Interaction): Interaction that invoked the command
+            length (int): Number of characters. Is SlashOption. Defaults to 12.
+        """
+
+        with Session(engine) as session:
+            stmt = (
+                select(CategoryGroup)
+                .where(CategoryGroup.GuildId == interaction.guild_id)
+                .where(CategoryGroup.GroupId == int(group_id))
+            )
+            group = session.scalar(stmt)
+            group.UsernameLength = length
+            session.commit()
+        await interaction.response.send_message(f"Username length set to {length}.", ephemeral=True)
+
+    @set.subcommand(description="Registers the channel for verification messages.")
+    async def verify_channel(
         self,
         interaction: nextcord.Interaction,
         channel: Optional[nextcord.abc.GuildChannel] = nextcord.SlashOption(
@@ -112,84 +187,21 @@ class SettingsManagementCog(commands.Cog, name="Settings Management"):
             channel (Optional[nextcord.abc.GuildChannel]): Channel to register
                 Is a SlashOption. Limited to text channels, Defaults to None.
         """
+
         if not channel:
             channel = interaction.channel
         channel_id = channel.id
-        stmt = select(Guild).where(Guild.GuildId == interaction.guild_id)
+        with Session(engine) as session:
-        guild = session.scalar(stmt)
+            stmt = select(Guild).where(Guild.GuildId == interaction.guild_id)
-        guild.VerificationChannel = channel_id
+            guild = session.scalar(stmt)
-        session.commit()
+            guild.VerificationChannel = channel_id
+            session.commit()
         await interaction.send(f"Registered <#{channel_id}>.", ephemeral=True)
 
-    @nextcord.slash_command(default_member_permissions=nextcord.Permissions(administrator=True))
-    async def set(self, interaction: nextcord.Interaction):
-        """
-        Parent slash command for setting settings. Never called.
-        """
-
-    @set.subcommand(
-        description="Set character length for a category. Can cut off username/score. Affects all categories."
-    )
-    async def category_pad_length(
-        self,
-        interaction: nextcord.Interaction,
-        group_id: str = nextcord.SlashOption(
-            name="group", description="Category Group to assign pad length to.", required=True
-        ),
-        length: int = nextcord.SlashOption(description="Number of characters.", required=True, default=26),
-    ) -> None:
-        """
-        Changes guild's category pad length.
-
-        Args:
-            interaction (nextcord.Interaction): Interaction that invoked the command
-            group_id (str): String representation of Group id to set pad length in. Is SlashOption.
-            length (int): Number of characters. Is SlashOption. Defaults to 26.
-        """
-
-        stmt = (
-            select(CategoryGroup)
-            .where(CategoryGroup.GuildId == interaction.guild_id)
-            .where(CategoryGroup.GroupId == int(group_id))
-        )
-        group = session.scalar(stmt)
-        group.PadLength = length
-        session.commit()
-        await interaction.response.send_message(
-            f"Category pad length set to {length} for {group.GroupName}", ephemeral=True
-        )
-
-    @set.subcommand(description="Set username length for a Group of Categories.")
-    async def username_length(
-        self,
-        interaction: nextcord.Interaction,
-        group_id: str = nextcord.SlashOption(
-            name="group", description="Group to change username length of.", required=True
-        ),
-        length: int = nextcord.SlashOption(description="Number of characters.", required=True, default=12),
-    ) -> None:
-        """
-        Changes guild's username length limit.
-
-        Args:
-            interaction (nextcord.Interaction): Interaction that invoked the command
-            length (int): Number of characters. Is SlashOption. Defaults to 12.
-        """
-
-        stmt = (
-            select(CategoryGroup)
-            .where(CategoryGroup.GuildId == interaction.guild_id)
-            .where(CategoryGroup.GroupId == int(group_id))
-        )
-        group = session.scalar(stmt)
-        group.UsernameLength = length
-        session.commit()
-        await interaction.response.send_message(f"Username length set to {length}.", ephemeral=True)
-
     @group_output_channel.on_autocomplete("group_id")
-    @category_pad_length.on_autocomplete("group_id")
+    @pad_length.on_autocomplete("group_id")
     @username_length.on_autocomplete("group_id")
-    async def group_id_autocomplete(self, interaction: nextcord.Interaction, group_id: str):
+    async def group_autocomplete(self, interaction: nextcord.Interaction, group_id: str):
         """
         Sends results from autofill_groups back to group_output_channel for autocompletion of group_id.
 

cogs/commands/update.py

@@ -0,0 +1,84 @@
+"""
+Commands for updating information/variables held in database.
+"""
+
+import nextcord
+from nextcord.ext import commands
+from sqlalchemy import select
+from sqlalchemy.orm import Session
+
+# pylint: disable=import-error
+from utilities.sql_data_classes import Guild, engine
+from utilities.utils import autofill_users_in_guild
+
+from .views.update_username_verify import UpdateUsernameVerifyView
+
+
+class UpdateCog(commands.Cog, name="Update commands."):
+    """
+    Class holds commands and views needed for updating things in bot.
+    """
+
+    def __init__(self, bot: commands.Bot):
+        """
+        Default constructor for Update class. Sets internal bot variable.
+
+        Args:
+            bot (commands.Bot): Bot object. Required to register update username button view.
+        """
+        self._bot: commands.Bot = bot
+
+    @commands.Cog.listener()
+    async def on_ready(self):
+        """
+        Called when cog is loaded. Adds views required for DataManagement commands.
+        """
+        self._bot.add_view(UpdateUsernameVerifyView())
+
+    @nextcord.slash_command()
+    async def update(self, interaction: nextcord.Interaction):
+        """
+        Parent slash command for updating things. Never called.
+        """
+
+    @update.subcommand(description="Request a username update. Admins must approve.")
+    async def username(
+        self,
+        interaction: nextcord.Interaction,
+        old_username: str = nextcord.SlashOption(description="Username currently stored in highscores.", required=True),
+        new_username: str = nextcord.SlashOption(description="Username to update to.", required=True),
+    ):
+        """
+        Creates a request to send to admins for changing a username. Uses
+        UpdateUsernameVerifyView to do the work.
+
+        Args:
+            interaction (nextcord.Interaction): Interaction that invoked the command
+            old_username (str): Username to replace.
+            new_username (str): Username to replace old with.
+        """
+
+        with Session(engine) as session:
+            stmt = select(Guild.VerificationChannel).where(Guild.GuildId == interaction.guild_id)
+            verify_channel = interaction.guild.get_channel(session.scalar(stmt))
+
+        embed: nextcord.Embed = nextcord.Embed(title="Username change request.")
+        embed.add_field(name="Old Username", value=old_username)
+        embed.add_field(name="New Username", value=new_username)
+        await verify_channel.send(
+            content=f"Username change request from <@{interaction.user.id}>.",
+            embed=embed,
+            view=UpdateUsernameVerifyView(),
+        )
+        await interaction.send("Request sent to admins for verification.", ephemeral=True)
+
+    @username.on_autocomplete("old_username")
+    async def all_users_autocomplete(self, interaction: nextcord.Interaction, username: str):
+        """
+        Sends response from autofill_users_in_guild back to update_username for autocompletion of old_username.
+
+        Args:
+            interaction (nextcord.Interaction): Interaction with command.
+            old_username (str): String to run autocompletion against.
+        """
+        await interaction.response.send_autocomplete(autofill_users_in_guild(interaction.guild_id, username))

cogs/commands/views/delete_confirm.py

@@ -0,0 +1,97 @@
+"""
+Contains view and helper functions for confirming and processing deletes.
+"""
+
+from typing import Optional
+
+import nextcord
+from sqlalchemy import delete, select
+from sqlalchemy.orm import Session
+
+# pylint: disable=import-error
+from utilities.sql_data_classes import Category, CategoryGroup, engine
+from utilities.utils import send_highscore_message
+
+
+class DeleteConfirmView(nextcord.ui.Modal):
+    """
+    View modal popup for confirming deletions.
+    """
+
+    def __init__(self, custom_id: str):
+        super().__init__(title="Warning, deletion is perminant.", custom_id=custom_id)
+
+        self.checker = nextcord.ui.TextInput(
+            label='Type "delete" to confirm deletion.',
+            required=True,
+            placeholder="delete",
+            style=nextcord.TextInputStyle.short,
+        )
+        self.add_item(self.checker)
+
+    async def callback(self, interaction: nextcord.Interaction):
+        if self.checker.value.lower() != "delete":
+            await interaction.response.send_message('Response was not "delete". Canceling delete.')
+            return
+
+        del_vals = parse_delete_id(self.custom_id)
+
+        with Session(engine) as session:
+            stmt = select(CategoryGroup).where(CategoryGroup.GroupId == del_vals["group_id"])
+            group = session.scalar(stmt)
+            if del_vals["category_id"] is None:
+                # delete entire group
+                session.delete(group)
+                # delete the message related to group
+                channel: nextcord.TextChannel = interaction.guild.get_channel(group.ChannelId)
+                message: nextcord.Message = await channel.fetch_message(group.MessageId)
+                await message.delete()
+
+            else:
+                stmt = (
+                    delete(Category)
+                    .where(Category.GroupId == del_vals["group_id"])
+                    .where(Category.CategoryId == del_vals["category_id"])
+                )
+                session.execute(stmt)
+                # update the message
+                await send_highscore_message(session, interaction.guild, group)
+            session.commit()
+
+        await interaction.response.send_message("Deletion complete.", ephemeral=True)
+
+
+def create_delete_id(group_id: int, category_id: Optional[int] = None) -> str:
+    """
+    Creates a delete id string to tell the view what to delete.
+
+    Args:
+        group_id (int): group id to delete
+        category_id (Optional[int]): category id to delete. Can be None.
+
+    Returns:
+        str: string representation of the delete id.
+    """
+    return f"delete-{group_id}-{category_id}"
+
+
+def parse_delete_id(delete_id: str) -> dict:
+    """
+    Returns a dict containing the values of a delete id.
+
+    Args:
+        id (str): the delete id
+
+    Returns:
+        dict: dict containing values from a delete id.
+    """
+    vals = {}
+    group_id = delete_id.split("-")[1]
+    category_id = delete_id.split("-")[2]
+    vals["group_id"] = group_id
+    if category_id == "None":
+        vals["category_id"] = None
+    else:
+        vals["category_id"] = category_id
+
+    return vals

cogs/commands/views/update_username_verify.py

@@ -2,9 +2,10 @@
 
 import nextcord
 from sqlalchemy import distinct, exc, select
+from sqlalchemy.orm import Session
 
 # pylint: disable=import-error
-from utilities.sql_alchemy_connection import Category, CategoryGroup, Score, session
+from utilities.sql_data_classes import Category, CategoryGroup, Score, engine
 from utilities.utils import send_highscore_message
 
 
@@ -43,32 +44,33 @@ class UpdateUsernameVerifyView(nextcord.ui.View):
             interaction (nextcord.Interaction): Interaction with the button
         """
 
-        try:
+        with Session(engine) as session:
-            embed_content = interaction.message.embeds[0].to_dict()
+            try:
-            old_username: str = embed_content["fields"][0]["value"]
+                embed_content = interaction.message.embeds[0].to_dict()
-            new_username: str = embed_content["fields"][1]["value"]
+                old_username: str = embed_content["fields"][0]["value"]
+                new_username: str = embed_content["fields"][1]["value"]
 
-            stmt = select(distinct(Score.CategoryId)).where(Score.UserName == old_username)
+                stmt = select(distinct(Score.CategoryId)).where(Score.UserName == old_username)
-            category_ids: "list[int]" = list(session.scalars(stmt))
+                category_ids: "list[int]" = list(session.scalars(stmt))
 
-            stmt = select(Score).where(Score.UserName == old_username)
+                stmt = select(Score).where(Score.UserName == old_username)
-            for score in session.scalars(stmt):
+                for score in session.scalars(stmt):
-                score.UserName = new_username
+                    score.UserName = new_username
-            session.commit()
+                session.commit()
 
-            group_ids = select(Category.GroupId).where(Category.CategoryId.in_(category_ids))
+                group_ids = select(Category.GroupId).where(Category.CategoryId.in_(category_ids))
 
-            stmt = select(CategoryGroup).where(CategoryGroup.GroupId.in_(group_ids))
+                stmt = select(CategoryGroup).where(CategoryGroup.GroupId.in_(group_ids))
 
-            for group in session.scalars(stmt):
+                for group in session.scalars(stmt):
-                await send_highscore_message(interaction.guild.get_channel(group.ChannelId), group)
+                    await send_highscore_message(session, interaction.guild, group)
 
-            content = interaction.message.content
+                content = interaction.message.content
-            content += f"\nApproved by <@{interaction.user.id}>."
+                content += f"\nApproved by <@{interaction.user.id}>."
-            await interaction.message.edit(content=content, embeds=interaction.message.embeds, view=None)
+                await interaction.message.edit(content=content, embeds=interaction.message.embeds, view=None)
-        except exc.DataError:
+            except exc.DataError:
-            session.rollback()
+                session.rollback()
-            content = interaction.message.content
+                content = interaction.message.content
-            content += "\nError, UserName is too long."
+                content += "\nError, UserName is too long."
-            await interaction.message.edit(content=content, embeds=interaction.message.embeds, view=None)
+                await interaction.message.edit(content=content, embeds=interaction.message.embeds, view=None)
-            await interaction.response.send_message(content="User must resubmit with shorter name.", ephemeral=True)
+                await interaction.response.send_message(content="User must resubmit with shorter name.", ephemeral=True)

cogs/guild_listener/__init__.py

@@ -4,9 +4,10 @@ Defines cog for guild listeners. Contains functions for various guild events.
 
 import nextcord
 from nextcord.ext import commands
+from sqlalchemy.orm import Session
 
 # pylint: disable=import-error
-from utilities.sql_alchemy_connection import Guild, session
+from utilities.sql_data_classes import Guild, engine
 from utilities.utils import add_preset_configuration
 
 
@@ -19,18 +20,12 @@ class GuildListener(commands.Cog, name="Guild Listener"):
     @commands.Cog.listener()
     async def on_guild_join(self, guild: nextcord.Guild):
         """Listener for Guild Join. Creates skeleton for new guild joined and saves it."""
+
         new_guild = Guild(GuildId=guild.id)
-        session.add(new_guild)
-        session.commit()
-        # This add config will be removed eventually. Config adding will have to be controlled by commands.
-        add_preset_configuration(guild.id, "runescape")
 
-        welcome_message: str = "Hello, I keep track of Highscores for you!"
+        with Session(engine) as session:
-        welcome_message += " Currently only supporting RuneScape boss highscores,"
+            session.add(new_guild)
-        welcome_message += " but will be more dynamic support in future."
+            session.commit()
-        welcome_message += ' For assistance on getting started, use "?register help".'
-
-        await guild.system_channel.send(content=welcome_message)
 
 
 # This function will be called when this extension is loaded.

cogs/message_listener/__init__.py

@@ -7,12 +7,12 @@ import re
 import nextcord
 from nextcord.ext import commands
 from sqlalchemy import select
-from sqlalchemy.orm import aliased
+from sqlalchemy.orm import Session
 
 # pylint: disable=import-error
 from classes.submission import SubmissionState
 from highscores import submission_objects
-from utilities.sql_alchemy_connection import Category, CategoryGroup, Guild, session
+from utilities.sql_data_classes import Category, Guild, engine
 
 
 class SubmissionListener(commands.Cog, name="Message Listener"):
@@ -33,66 +33,68 @@ class SubmissionListener(commands.Cog, name="Message Listener"):
         if submission_objects.has_user(message.author.id):
             submission = submission_objects.get_user_submission(message.author.id)
             message_id = submission.message_id
-            stmt = select(Guild.SubmissionChannel).where(Guild.GuildId == guild_id)
-            submission_channel_id = session.scalar(stmt)
-            submission_message: nextcord.Message = (
-                await self.bot.get_guild(guild_id).get_channel(submission_channel_id).fetch_message(message_id)
-            )
 
-            # need check if correct user and correct channel
+            with Session(engine) as session:
-            if message.channel.id == submission_channel_id:
+                stmt = select(Guild.SubmissionChannel).where(Guild.GuildId == guild_id)
-                state = submission.submission_state
+                submission_channel_id = session.scalar(stmt)
-                if state == SubmissionState.SCORE and message.content:
+                submission_message: nextcord.Message = (
+                    await self.bot.get_guild(guild_id).get_channel(submission_channel_id).fetch_message(message_id)
+                )
 
-                    stmt = select(Category.IsTimeRecord).where(Category.CategoryId == submission.category_id)
+                # need check if correct user and correct channel
+                if message.channel.id == submission_channel_id:
+                    state = submission.submission_state
+                    if state == SubmissionState.SCORE and message.content:
 
-                    # check with regex if score matches correctly
+                        stmt = select(Category.IsTimeRecord).where(Category.CategoryId == submission.category_id)
-                    is_time_record = session.scalar(stmt)
 
-                    time_regex = re.search("^([0-9]{1,2}:[0-9]|[0-9])?[0-9](\\.[0-9])?$", message.content)
+                        # check with regex if score matches correctly
-                    int_regex = re.search("^[0-9]+$", message.content)
+                        is_time_record = session.scalar(stmt)
-                    if time_regex is None and is_time_record:
+
-                        embeds = submission_message.embeds[0]
+                        time_regex = re.search("^([0-9]{1,2}:[0-9]|[0-9])?[0-9](\\.[0-9])?$", message.content)
-                        embeds.add_field(
+                        int_regex = re.search("^[0-9]+$", message.content)
-                            name="Error",
+                        if time_regex is None and is_time_record:
-                            value="Time record must follow format MM:SS.ms, SS.ms, or SS.",
+                            embeds = submission_message.embeds[0]
+                            embeds.add_field(
+                                name="Error",
+                                value="Time record must follow format MM:SS.ms, SS.ms, or SS.",
+                            )
+                        elif int_regex is None and not is_time_record:
+                            embeds = submission_message.embeds[0]
+                            embeds.add_field(name="Error", value="Number record must only be number.")
+                        else:
+                            score = message.content
+                            if is_time_record:
+                                # standardize time score format.
+                                if re.search("^[1-9]?[0-9]:[0-9]{2}(\\.[0-9])?$", score):
+                                    # score is already fine.
+                                    pass
+                                elif re.search("^[0-9]{2}(\\.[0-9])?$", score):
+                                    # need to add leading colon and 0
+                                    score = "0:" + score
+                                elif re.search("^[0-9](\\.[0-9])?$", score):
+                                    # need to add 0 in seconds and leading colon and 0
+                                    score = "0:0" + score
+                                elif re.search("^[0]?[0-9]:[0-9]{2}(\\.[0-9])?$", score):
+                                    # if there is a minute 10ths place 0, remove
+                                    score = score.lstrip("0")
+                            submission.score = score
+                            embeds = submission.get_embeds()
+                        await submission_message.edit(
+                            embeds=embeds,
                         )
-                    elif int_regex is None and not is_time_record:
+                    elif state == SubmissionState.PROOF and len(message.attachments) > 0:
-                        embeds = submission_message.embeds[0]
+                        await submission_message.edit(
-                        embeds.add_field(name="Error", value="Number record must only be number.")
+                            files=[await attch.to_file() for attch in message.attachments],
-                    else:
+                        )
-                        score = message.content
+                    elif state == SubmissionState.NAME and message.content:
-                        if is_time_record:
+                        submission.username = message.content
-                            # standardize time score format.
-                            if re.search("^[1-9]?[0-9]:[0-9]{2}(\\.[0-9])?$", score):
-                                # score is already fine.
-                                pass
-                            elif re.search("^[0-9]{2}(\\.[0-9])?$", score):
-                                # need to add leading colon and 0
-                                score = "0:" + score
-                            elif re.search("^[0-9](\\.[0-9])?$", score):
-                                # need to add 0 in seconds and leading colon and 0
-                                score = "0:0" + score
-                            elif re.search("^[0]?[0-9]:[0-9]{2}(\\.[0-9])?$", score):
-                                # if there is a minute 10ths place 0, remove
-                                score = score.lstrip("0")
-                        submission.score = score
                         embeds = submission.get_embeds()
-                    await submission_message.edit(
+                        await submission_message.edit(
-                        embeds=embeds,
+                            embeds=embeds,
-                    )
+                        )
-                elif state == SubmissionState.PROOF and len(message.attachments) > 0:
-                    await submission_message.edit(
-                        files=[await attch.to_file() for attch in message.attachments],
-                    )
-                elif state == SubmissionState.NAME and message.content:
-                    submission.username = message.content
-                    embeds = submission.get_embeds()
-                    await submission_message.edit(
-                        embeds=embeds,
-                    )
 
-                await message.delete()
+                    await message.delete()
 
 
 # This function will be called when this extension is loaded.

cogs/submission/submission_views.py

@@ -5,12 +5,12 @@ from typing import Optional
 import nextcord
 from nextcord.ext import commands
 from sqlalchemy import select
-from sqlalchemy.orm import aliased
+from sqlalchemy.orm import Session, aliased
 
 # pylint: disable=import-error
 from classes.submission import Submission, SubmissionState
-from utilities.sql_alchemy_connection import Category, Guild, CategoryGroup, session
 from highscores import submission_objects
+from utilities.sql_data_classes import Category, CategoryGroup, Guild, engine
 
 from .verification_view import VerificationView
 
@@ -18,12 +18,14 @@ from .verification_view import VerificationView
 def category_select_options(group_id: int) -> "list[nextcord.SelectOption]":
     """Returns list of categories for a given boss."""
     options: "list[nextcord.SelectOption]" = []
-    subq = select(CategoryGroup).where(CategoryGroup.GroupId == group_id).subquery()
+
-    cat_group_alias = aliased(CategoryGroup, subq)
+    with Session(engine) as session:
-    stmt = select(Category).where(Category.GroupId == cat_group_alias.GroupId)
+        subq = select(CategoryGroup).where(CategoryGroup.GroupId == group_id).subquery()
-    categories_list = session.scalars(stmt)
+        cat_group_alias = aliased(CategoryGroup, subq)
-    for category in categories_list:
+        stmt = select(Category).where(Category.GroupId == cat_group_alias.GroupId)
-        options.append(nextcord.SelectOption(label=category.CategoryName, value=str(category.CategoryId)))
+        categories_list = session.scalars(stmt)
+        for category in categories_list:
+            options.append(nextcord.SelectOption(label=category.CategoryName, value=str(category.CategoryId)))
 
     return options
 
@@ -110,8 +112,9 @@ class SubmitButton(nextcord.ui.Button):
         self._bot = bot
 
     async def callback(self, interaction: nextcord.Interaction):
-        stmt = select(Guild.VerificationChannel).where(Guild.GuildId == interaction.guild_id)
+        with Session(engine) as session:
-        verification_channel_id = session.scalar(stmt)
+            stmt = select(Guild.VerificationChannel).where(Guild.GuildId == interaction.guild_id)
+            verification_channel_id = session.scalar(stmt)
         channel = interaction.guild.get_channel(verification_channel_id)
         submission = submission_objects.get_user_submission(interaction.user.id)
 
@@ -148,20 +151,22 @@ class SubmissionCreateButton(nextcord.ui.View):
         self, button: nextcord.ui.Button, interaction: nextcord.Interaction
     ):  # pylint: disable=unused-argument
         """Button for score submission."""
+
         # Don't allow a user to start a new submission if one already exists
         if submission_objects.has_user(interaction.user.id):
             await interaction.send("Please finish in progress submission first.", ephemeral=True)
             return
 
-        stmt = (
+        with Session(engine) as session:
-            select(CategoryGroup.GroupId)
+            stmt = (
-            .where(CategoryGroup.GuildId == interaction.guild_id)
+                select(CategoryGroup.GroupId)
-            .where(CategoryGroup.MessageId == interaction.message.id)
+                .where(CategoryGroup.GuildId == interaction.guild_id)
-        )
+                .where(CategoryGroup.MessageId == interaction.message.id)
-        group_id = session.scalar(stmt)
+            )
+            group_id = session.scalar(stmt)
 
-        stmt = select(Guild.SubmissionChannel).where(Guild.GuildId == interaction.guild_id)
+            stmt = select(Guild.SubmissionChannel).where(Guild.GuildId == interaction.guild_id)
-        channel = interaction.guild.get_channel(session.scalar(stmt))
+            channel = interaction.guild.get_channel(session.scalar(stmt))
 
         # a user should only have 1 submission active at once.
         # split username on pipe. Decided to store whole username...

docker-compose.yml

@@ -1,6 +1,7 @@
 version: "3"
 services:
   sqldb:
+    restart: unless-stopped
     image: "highscores_db"
     container_name: "Highscores-DataBase"
     volumes:
@@ -12,4 +13,4 @@ services:
       - MYSQL_ROOT_USERNAME=${SQL_USER}
 
 volumes:
-  highscores_data:
+  highscores_data:

highscores.py

@@ -9,7 +9,8 @@ import sys
 import nextcord
 from nextcord.ext import commands
 
-import utilities.config as config
+# pylint: disable=import-error
+from utilities import config
 from classes.submission import SubmissionMap
 
 logger = logging.getLogger("nextcord")

utilities/sql_data_classes.py

@@ -3,17 +3,15 @@ Simple file to set up the sqlalchemy connection to database.
 """
 from sqlalchemy import create_engine
 from sqlalchemy.ext.automap import automap_base
-from sqlalchemy.orm import Session
 
-import utilities.config as config
+# pylint: disable=import-error
+from utilities import config
 
 # connect with sql alchemy and autoload schema
 url = f"mysql://{config.SQL_USER}:{config.SQL_PASS}@{config.SQL_HOST}/{config.SQL_DB}"
 engine = create_engine(url)
-connection = engine.connect()
 Base = automap_base()
 Base.prepare(autoload_with=engine)
-session = Session(engine)
 
 # define the classes
 Guild = Base.classes.Guilds

utilities/utils.py

@@ -8,10 +8,10 @@ import time
 import nextcord
 import pandas as pd
 from sqlalchemy import distinct, select
-from sqlalchemy.orm import aliased
+from sqlalchemy.orm import Session, aliased
 
 # pylint: disable=import-error
-from utilities.sql_alchemy_connection import Category, CategoryGroup, Guild, Score, engine, session
+from utilities.sql_data_classes import Category, CategoryGroup, Guild, Score, engine
 
 MAX_LINE_LENGTH = 142
 
@@ -30,16 +30,17 @@ def autofill_categories(guild_id: int, group_id: int, category_begin: str) -> "d
         dict[str, str]: List of all category names that start with category_begin.
     """
 
-    # search database for all category names
+    with Session(engine) as session:
-    subq = (
+        # search database for all category names
-        select(CategoryGroup)
+        subq = (
-        .where(CategoryGroup.GuildId == guild_id)
+            select(CategoryGroup)
-        .where(CategoryGroup.GroupId == group_id)
+            .where(CategoryGroup.GuildId == guild_id)
-        .subquery()
+            .where(CategoryGroup.GroupId == group_id)
-    )
+            .subquery()
-    cat_group_alias = aliased(CategoryGroup, subq)
+        )
-    stmt = select(Category).where(Category.GroupId == cat_group_alias.GroupId)
+        cat_group_alias = aliased(CategoryGroup, subq)
-    categories_dict: dict = {cat.CategoryName: str(cat.CategoryId) for cat in session.scalars(stmt)}
+        stmt = select(Category).where(Category.GroupId == cat_group_alias.GroupId)
+        categories_dict: dict = {cat.CategoryName: str(cat.CategoryId) for cat in session.scalars(stmt)}
 
     # if string empty, return all category names
     if not category_begin:
@@ -65,11 +66,12 @@ def autofill_groups(guild_id: int, group_begin: str) -> "dict[str, str]":
         dict[str, str]: Dict of group names and ids where group name start with group_begin. Key is name, value is id.
     """
 
-    # Select all groups in guild.
+    with Session(engine) as session:
-    stmt = select(CategoryGroup).where(CategoryGroup.GuildId == guild_id)
+        # Select all groups in guild.
+        stmt = select(CategoryGroup).where(CategoryGroup.GuildId == guild_id)
 
-    # dict has to have key values of same type for discord.
+        # dict has to have key values of same type for discord.
-    group_dict: dict = {group.GroupName: str(group.GroupId) for group in session.scalars(stmt)}
+        group_dict: dict = {group.GroupName: str(group.GroupId) for group in session.scalars(stmt)}
 
     # if string empty, return all group names
     if not group_begin:
@@ -98,32 +100,33 @@ def autofill_users_in_group_category(guild_id: int, group_id: int, category_id:
         list[str]: List of users that start with user_begin.
     """
 
-    # get all categories in the group
+    with Session(engine) as session:
-    subq = (
+        # get all categories in the group
-        select(CategoryGroup)
-        .where(CategoryGroup.GuildId == guild_id)
-        .where(CategoryGroup.GroupId == group_id)
-        .subquery()
-    )
-    category_group = aliased(CategoryGroup, subq)
-
-    # If no category id, get all users in group.
-    if category_id == 0:
-        subq = select(Category.CategoryId).where(Category.GroupId == category_group.GroupId)
-        stmt = select(distinct(Score.UserName)).where(Score.CategoryId.in_(subq))
-
-    else:
-        # get all users in category_id
         subq = (
-            select(Category)
+            select(CategoryGroup)
-            .where(Category.GroupId == category_group.GroupId)
+            .where(CategoryGroup.GuildId == guild_id)
-            .where(Category.CategoryId == category_id)
+            .where(CategoryGroup.GroupId == group_id)
             .subquery()
         )
-        category = aliased(Category, subq)
+        category_group = aliased(CategoryGroup, subq)
-        stmt = select(distinct(Score.UserName)).where(Score.CategoryId == category.CategoryId)
 
-    users_list: "list[str]" = list(session.scalars(stmt))
+        # If no category id, get all users in group.
+        if category_id == 0:
+            subq = select(Category.CategoryId).where(Category.GroupId == category_group.GroupId)
+            stmt = select(distinct(Score.UserName)).where(Score.CategoryId.in_(subq))
+
+        else:
+            # get all users in category_id
+            subq = (
+                select(Category)
+                .where(Category.GroupId == category_group.GroupId)
+                .where(Category.CategoryId == category_id)
+                .subquery()
+            )
+            category = aliased(Category, subq)
+            stmt = select(distinct(Score.UserName)).where(Score.CategoryId == category.CategoryId)
+
+        users_list: "list[str]" = list(session.scalars(stmt))
 
     # if string empty, return all users
     if not user_begin:
@@ -146,10 +149,12 @@ def autofill_users_in_guild(guild_id: int, user_begin: str) -> "list[str]":
     Returns:
         list[str]: All users with submissions in the guild.
     """
-    group_ids = select(CategoryGroup.GroupId).where(CategoryGroup.GuildId == guild_id)
+
-    category_ids = select(Category.CategoryId).where(Category.GroupId.in_(group_ids))
+    with Session(engine) as session:
-    stmt = select(distinct(Score.UserName)).where(Score.CategoryId.in_(category_ids))
+        group_ids = select(CategoryGroup.GroupId).where(CategoryGroup.GuildId == guild_id)
-    users_list: "list[str]" = list(session.scalars(stmt))
+        category_ids = select(Category.CategoryId).where(Category.GroupId.in_(group_ids))
+        stmt = select(distinct(Score.UserName)).where(Score.CategoryId.in_(category_ids))
+        users_list: "list[str]" = list(session.scalars(stmt))
 
     # if string empty, return all users
     if not user_begin:
@@ -161,18 +166,20 @@ def autofill_users_in_guild(guild_id: int, user_begin: str) -> "list[str]":
     return users
 
 
-def format_highscore_message(group: CategoryGroup) -> str:
+def format_highscore_message(session: Session, group: CategoryGroup) -> str:
     """
     Creates a formatted string for a boss's highscore discord message.
     This formatted string is in discord's code block to ensure monospace text.
     Loops through each category to build the message one place at a time.
 
     Args:
-        group (group): group object that contains the contents of the message.
+        session (Session): the sqlalchemy session used for this function call.
+        group (CategoryGroup): group object that contains the contents of the message.
 
     Returns:
         str: Formatted string for discord message
     """
+
     ret_string = f"**{group.GroupName}**\n```"
 
     stmt = select(Guild).where(Guild.GuildId == group.GuildId)
@@ -291,28 +298,31 @@ def get_time_str(time_in: float) -> str:
     return time.strftime(f"%-M:%S.{milliseconds}", time.gmtime(time_in))
 
 
-async def send_highscore_message(channel: nextcord.TextChannel, group: CategoryGroup) -> nextcord.Message:
+async def send_highscore_message(session: Session, guild: nextcord.Guild, group: CategoryGroup) -> nextcord.Message:
     """
     Function takes care of checking if a message exists for a group.
     Creates and sends/edits the message.
 
     Args:
-        channel (nextcord.TextChannel): Discord channel object where message is sent
+        session (Session): The sqlalchemy session being used for this function call.
-        group (CategoryGroup): group to post to the message
+        guild (nextcord.Guild): the nextcord.Guild object requesting this message.
+        group (CategoryGroup): group to post to the message.
 
     Returns:
-        nextcord.Message: Message object that was posted with group contents
+        nextcord.Message: Message object that was posted with group contents.
     """
-    highscore_string = format_highscore_message(group)
 
-    try:
+    highscore_string = format_highscore_message(session, group)
-        message: nextcord.Message = await channel.fetch_message(group.MessageId)
+    channel = guild.get_channel(group.ChannelId)
-        await message.edit(content=highscore_string)
+
-    except nextcord.NotFound:
+    if group.MessageId is None:
         # message doesn't exist.
         message: nextcord.Message = await channel.send(highscore_string)
         group.MessageId = message.id
         session.commit()
+    else:
+        message: nextcord.Message = await channel.fetch_message(group.MessageId)
+        await message.edit(content=highscore_string)
 
     return message
 
@@ -332,37 +342,31 @@ async def submit_score(
         score (str): Score to submit. Need to convert to correct type.
     """
 
-    stmt = select(Category.IsTimeRecord).where(Category.CategoryId == category_id)
+    with Session(engine) as session:
-    is_time_record = session.scalar(stmt)
+        stmt = select(Category.IsTimeRecord).where(Category.CategoryId == category_id)
+        is_time_record = session.scalar(stmt)
 
-    if is_time_record:
+        if is_time_record:
-        minutes = float(score.split(":", maxsplit=1)[0])
+            minutes = float(score.split(":", maxsplit=1)[0])
-        seconds = float(score.split(":", maxsplit=1)[1])
+            seconds = float(score.split(":", maxsplit=1)[1])
-        score = (minutes * 60) + seconds
+            score = (minutes * 60) + seconds
-    else:
+        else:
-        score = float(score)
+            score = float(score)
 
-    stmt = select(Score).where(Score.UserName == username).where(Score.CategoryId == category_id)
+        stmt = select(Score).where(Score.UserName == username).where(Score.CategoryId == category_id)
-    existing_score = session.scalar(stmt)
+        existing_score = session.scalar(stmt)
 
-    if existing_score:
+        if existing_score:
-        existing_score.Score = score
+            existing_score.Score = score
-    else:
+        else:
-        score_obj = Score(UserName=username, Score=score, CategoryId=category_id)
+            score_obj = Score(UserName=username, Score=score, CategoryId=category_id)
-        session.add(score_obj)
+            session.add(score_obj)
-    session.commit()
+        session.commit()
 
-    stmt = select(CategoryGroup).where(CategoryGroup.GroupId == group_id)
+        stmt = select(CategoryGroup).where(CategoryGroup.GroupId == group_id)
-    group = session.scalar(stmt)
+        group = session.scalar(stmt)
 
-    # edit message
+        await send_highscore_message(session, interaction.guild, group)
-    channel = interaction.guild.get_channel(group.ChannelId)
-
-    error_response = "Registered Highscores channel does not exist or was never registered."
-    error_response += 'Register with "/register" command.'
-    assert channel is not None, await interaction.send(error_response, ephemeral=True)
-
-    await send_highscore_message(channel, group)
 
 
 def add_preset_configuration(guild_id: int, config_str: str) -> None:
@@ -374,19 +378,21 @@ def add_preset_configuration(guild_id: int, config_str: str) -> None:
         guild_id (int): Guild id to add config to
         config_str (str): Config name to add
     """
-    with open(f"example_config/{config_str}.json", encoding="utf-8", mode="r") as file:
-        config = json.load(file)
 
-    for group_name, categorys in config["tables"].items():
+    with Session(engine) as session:
-        group_obj = CategoryGroup(GroupName=group_name, GuildId=guild_id)
+        with open(f"example_config/{config_str}.json", encoding="utf-8", mode="r") as file:
-        session.add(group_obj)
+            config = json.load(file)
-        for category_name in categorys:
-            cat_obj = Category(
-                CategoryName=category_name,
-                Size=config["table_size"],
-                IsTimeRecord=config["categories"][category_name]["is_time_record"],
-                IsAscending=config["categories"][category_name]["ascending"],
-            )
-            session.add(cat_obj)
 
-    session.commit()
+        for group_name, categorys in config["tables"].items():
+            group_obj = CategoryGroup(GroupName=group_name, GuildId=guild_id)
+            session.add(group_obj)
+            for category_name in categorys:
+                cat_obj = Category(
+                    CategoryName=category_name,
+                    Size=config["table_size"],
+                    IsTimeRecord=config["categories"][category_name]["is_time_record"],
+                    IsAscending=config["categories"][category_name]["ascending"],
+                )
+                session.add(cat_obj)
+
+        session.commit()