From 582b88e24826480841d295047364c270465cec2d Mon Sep 17 00:00:00 2001 From: alwayscompiling Date: Sun, 4 Dec 2022 22:42:55 -0500 Subject: [PATCH 01/12] Create set command over Settings Management. --- cogs/commands/__init__.py | 4 +- .../{settings_management.py => set.py} | 198 +++++++++--------- 2 files changed, 98 insertions(+), 104 deletions(-) rename cogs/commands/{settings_management.py => set.py} (89%) diff --git a/cogs/commands/__init__.py b/cogs/commands/__init__.py index 0107117..79a9734 100644 --- a/cogs/commands/__init__.py +++ b/cogs/commands/__init__.py @@ -7,7 +7,7 @@ from nextcord.ext import commands # Command classes from .data_management import DataManagementCog from .message_management import MessageManagementCog -from .settings_management import SettingsManagementCog +from .set import SetCog # This function will be called when this extension is loaded. @@ -18,4 +18,4 @@ def setup(bot: commands.Bot): """ bot.add_cog(DataManagementCog(bot)) bot.add_cog(MessageManagementCog(bot)) - bot.add_cog(SettingsManagementCog()) + bot.add_cog(SetCog()) diff --git a/cogs/commands/settings_management.py b/cogs/commands/set.py similarity index 89% rename from cogs/commands/settings_management.py rename to cogs/commands/set.py index bca7364..5e2dd80 100644 --- a/cogs/commands/settings_management.py +++ b/cogs/commands/set.py @@ -1,5 +1,5 @@ """ -Commands for managing the Guild's settings. +Set command heirarchy. """ from typing import Optional @@ -13,114 +13,16 @@ from utilities.sql_alchemy_connection import CategoryGroup, Guild, session from utilities.utils import 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): - """ - Parent slash command, never called. - """ - - @register.subcommand(description="Registers the channel for a Category Group's messages.") - async def group_output_channel( - self, - interaction: nextcord.Interaction, - group_id: str = nextcord.SlashOption( - name="group", description="Category Group to assign to channel.", required=True - ), - channel: Optional[nextcord.abc.GuildChannel] = nextcord.SlashOption( - description="Channel to register", - required=False, - channel_types=[nextcord.ChannelType.text], - default=None, - ), - ) -> None: - """ - Command function to register a CategoryGroup's output channel. - - Args: - interaction (nextcord.Interaction): Interaction that invoked the command - group_id (str): String representation of Group id to register channel to. Is SlashOption. - 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 = ( - select(CategoryGroup) - .where(CategoryGroup.GuildId == interaction.guild_id) - .where(CategoryGroup.GroupId == int(group_id)) - ) - group = session.scalar(stmt) - group.ChannelId = channel_id - session.commit() - await interaction.send(f"Registered <#{channel_id}>.", ephemeral=True) - - @register.subcommand(description="Registers the channel for submission messages.") - async def submission( - self, - interaction: nextcord.Interaction, - channel: Optional[nextcord.abc.GuildChannel] = nextcord.SlashOption( - description="Channel to register", - required=False, - channel_types=[nextcord.ChannelType.text], - default=None, - ), - ) -> None: - """ - Command function to register the submission message channel. - - Args: - interaction (nextcord.Interaction): Interaction that invoked the command - 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) - 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.") - async def verify( - self, - interaction: nextcord.Interaction, - channel: Optional[nextcord.abc.GuildChannel] = nextcord.SlashOption( - description="Channel to register", - required=False, - channel_types=[nextcord.ChannelType.text], - default=None, - ), - ) -> None: - """ - Command function to register the verification message channel. - - Args: - interaction (nextcord.Interaction): Interaction that invoked the command - 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) - guild = session.scalar(stmt) - 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): """ @@ -159,6 +61,70 @@ class SettingsManagementCog(commands.Cog, name="Settings Management"): f"Category pad length set to {length} for {group.GroupName}", ephemeral=True ) + @set.subcommand(description="Registers the channel for a Category Group's messages.") + async def group_output_channel( + self, + interaction: nextcord.Interaction, + group_id: str = nextcord.SlashOption( + name="group", description="Category Group to assign to channel.", required=True + ), + channel: Optional[nextcord.abc.GuildChannel] = nextcord.SlashOption( + description="Channel to register", + required=False, + channel_types=[nextcord.ChannelType.text], + default=None, + ), + ) -> None: + """ + Command function to register a CategoryGroup's output channel. + + Args: + interaction (nextcord.Interaction): Interaction that invoked the command + group_id (str): String representation of Group id to register channel to. Is SlashOption. + 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 = ( + select(CategoryGroup) + .where(CategoryGroup.GuildId == interaction.guild_id) + .where(CategoryGroup.GroupId == int(group_id)) + ) + group = session.scalar(stmt) + group.ChannelId = channel_id + session.commit() + await interaction.send(f"Registered <#{channel_id}>.", 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( + description="Channel to register", + required=False, + channel_types=[nextcord.ChannelType.text], + default=None, + ), + ) -> None: + """ + Command function to register the submission message channel. + + Args: + interaction (nextcord.Interaction): Interaction that invoked the command + 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) + guild = session.scalar(stmt) + guild.SubmissionChannel = channel_id + session.commit() + await interaction.send(f"Registered <#{channel_id}>.", ephemeral=True) + @set.subcommand(description="Set username length for a Group of Categories.") async def username_length( self, @@ -186,6 +152,34 @@ class SettingsManagementCog(commands.Cog, name="Settings Management"): 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( + description="Channel to register", + required=False, + channel_types=[nextcord.ChannelType.text], + default=None, + ), + ) -> None: + """ + Command function to register the verification message channel. + + Args: + interaction (nextcord.Interaction): Interaction that invoked the command + 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) + guild = session.scalar(stmt) + guild.VerificationChannel = channel_id + session.commit() + await interaction.send(f"Registered <#{channel_id}>.", ephemeral=True) + @group_output_channel.on_autocomplete("group_id") @category_pad_length.on_autocomplete("group_id") @username_length.on_autocomplete("group_id") From d04b8c5e32504416f4ff7d4bddf138150ebdd1cb Mon Sep 17 00:00:00 2001 From: alwayscompiling Date: Tue, 6 Dec 2022 23:02:01 -0500 Subject: [PATCH 02/12] Squashed commit of the following: commit 3627419e12af2003c695e5c362445d49ad11374b Merge: 2db744d 3446ce9 Author: alwayscompiling Date: Tue Dec 6 22:36:51 2022 -0500 Merge branch '45-sql-connection-timing-out' into develop commit 3446ce9ca28191742627ff4d82035b1105c87d39 Author: alwayscompiling Date: Tue Dec 6 22:27:05 2022 -0500 Change session usage to on use basis. commit 2db744d1702d88863d472adff885f52f23447456 Author: alwayscompiling Date: Sun Dec 4 21:44:54 2022 -0500 Add restart policy. commit fa33be1b4aba38d4cdd1dfc9fab98c819a7d88fe Author: alwayscompiling Date: Sun Dec 4 21:25:57 2022 -0500 Renamed docker compose file. --- classes/submission.py | 20 +- cogs/commands/data_management.py | 76 ++++---- cogs/commands/message_management.py | 79 ++++---- cogs/commands/set.py | 84 ++++---- cogs/commands/views/update_username_verify.py | 50 ++--- cogs/guild_listener/__init__.py | 10 +- cogs/message_listener/__init__.py | 112 +++++------ cogs/submission/submission_views.py | 41 ++-- highscores_compose.yaml => docker-compose.yml | 3 +- highscores.py | 3 +- ...hemy_connection.py => sql_data_classes.py} | 6 +- utilities/utils.py | 182 ++++++++++-------- 12 files changed, 359 insertions(+), 307 deletions(-) rename highscores_compose.yaml => docker-compose.yml (86%) rename utilities/{sql_alchemy_connection.py => sql_data_classes.py} (80%) diff --git a/classes/submission.py b/classes/submission.py index 88742a5..405cdd4 100644 --- a/classes/submission.py +++ b/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) - if self.category_id: - stmt = ( - select(Category.CategoryName) - .where(Category.GroupId == self.group_id) - .where(Category.CategoryId == self.category_id) - ) - embed.add_field(name="Category", value=session.scalar(stmt), inline=False) + with Session(engine) as session: + embed.add_field(name="Group", value=session.scalar(stmt), inline=False) + if self.category_id: + stmt = ( + select(Category.CategoryName) + .where(Category.GroupId == self.group_id) + .where(Category.CategoryId == self.category_id) + ) + embed.add_field(name="Category", value=session.scalar(stmt), inline=False) if self.score: embed.add_field(name="Score", value=self.score, inline=False) diff --git a/cogs/commands/data_management.py b/cogs/commands/data_management.py index 5e16f08..223d809 100644 --- a/cogs/commands/data_management.py +++ b/cogs/commands/data_management.py @@ -7,9 +7,10 @@ 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_alchemy_connection import Category, CategoryGroup, Guild, Score, session +from utilities.sql_data_classes import Category, CategoryGroup, Guild, Score, engine from utilities.utils import ( autofill_categories, autofill_groups, @@ -70,20 +71,21 @@ class DataManagementCog(commands.Cog, name="Table Management"): 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)) + 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() + 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)) + 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): - await send_highscore_message(interaction.guild.get_channel(group.ChannelId), group) + for group in session.scalars(stmt): + await send_highscore_message(session, interaction.guild.get_channel(group.ChannelId), group) await interaction.send(f'User "{user_name}" was removed from all tables.', ephemeral=True) @@ -107,20 +109,23 @@ class DataManagementCog(commands.Cog, name="Table Management"): user_name (str): The user to remove. Is SlashOption. """ - stmt = select(CategoryGroup).where(CategoryGroup.GroupId == int(group_id)) - group = session.scalar(stmt) + 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(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) + 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() + # 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) + await send_highscore_message(session, 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( @@ -138,19 +143,20 @@ class DataManagementCog(commands.Cog, name="Table Management"): 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) + 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() + 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 - ) + await send_highscore_message(session, 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") @@ -215,8 +221,10 @@ class DataManagementCog(commands.Cog, name="Table Management"): 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)) + + 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) diff --git a/cogs/commands/message_management.py b/cogs/commands/message_management.py index c90810a..bbbb870 100644 --- a/cogs/commands/message_management.py +++ b/cogs/commands/message_management.py @@ -7,10 +7,11 @@ 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 cogs.submission.submission_views import SubmissionCreateButton -from utilities.sql_alchemy_connection import CategoryGroup, session +from utilities.sql_data_classes import CategoryGroup, engine from utilities.utils import autofill_groups, send_highscore_message @@ -55,23 +56,24 @@ class MessageManagementCog(commands.Cog, name="Message Management"): 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) + 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) + 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 + 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) @@ -90,21 +92,23 @@ class MessageManagementCog(commands.Cog, name="Message Management"): 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) + with Session(engine) as session: + stmt = select(CategoryGroup).where(CategoryGroup.GuildId == interaction.guild_id) - for group in session.scalars(stmt): - channel = interaction.guild.get_channel(group.ChannelId) + # awaiting response because posting scores takes a while + await interaction.response.defer(ephemeral=True) - # 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) + for group in session.scalars(stmt): + channel = interaction.guild.get_channel(group.ChannelId) - message: nextcord.Message = await send_highscore_message(channel, group) - await message.edit(view=SubmissionCreateButton(self.bot)) + # 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(session, channel, group) + await message.edit(view=SubmissionCreateButton(self.bot)) await interaction.send(f"Posted all groups in {interaction.guild.name}'s highscores.", ephemeral=True) @@ -125,19 +129,20 @@ class MessageManagementCog(commands.Cog, name="Message Management"): 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) + with Session(engine) as session: + 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) + channel = interaction.guild.get_channel(group.ChannelId) - message: nextcord.Message = await send_highscore_message(channel, group) - await message.edit(view=SubmissionCreateButton(self.bot)) + message: nextcord.Message = await send_highscore_message(session, channel, group) + await message.edit(view=SubmissionCreateButton(self.bot)) - await interaction.response.send_message(f"Updated table {group.GroupName}!", ephemeral=True) + 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): diff --git a/cogs/commands/set.py b/cogs/commands/set.py index 5e2dd80..7f65318 100644 --- a/cogs/commands/set.py +++ b/cogs/commands/set.py @@ -7,9 +7,10 @@ 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 @@ -49,17 +50,18 @@ class SetCog(commands.Cog, name="Set command."): 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 - ) + 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 a Category Group's messages.") async def group_output_channel( @@ -84,17 +86,19 @@ class SetCog(commands.Cog, name="Set command."): 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 = ( - select(CategoryGroup) - .where(CategoryGroup.GuildId == interaction.guild_id) - .where(CategoryGroup.GroupId == int(group_id)) - ) - group = session.scalar(stmt) - group.ChannelId = channel_id - session.commit() + 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.ChannelId = channel_id + session.commit() await interaction.send(f"Registered <#{channel_id}>.", ephemeral=True) @set.subcommand(description="Registers the channel for submission messages.") @@ -116,13 +120,16 @@ class SetCog(commands.Cog, name="Set command."): 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) - guild = session.scalar(stmt) - guild.SubmissionChannel = channel_id - session.commit() + + with Session(engine) as session: + channel_id = channel.id + stmt = select(Guild).where(Guild.GuildId == interaction.guild_id) + guild = session.scalar(stmt) + guild.SubmissionChannel = channel_id + session.commit() await interaction.send(f"Registered <#{channel_id}>.", ephemeral=True) @set.subcommand(description="Set username length for a Group of Categories.") @@ -142,14 +149,15 @@ class SetCog(commands.Cog, name="Set 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() + 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.") @@ -171,13 +179,15 @@ class SetCog(commands.Cog, name="Set command."): 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) - guild = session.scalar(stmt) - guild.VerificationChannel = channel_id - session.commit() + with Session(engine) as session: + stmt = select(Guild).where(Guild.GuildId == interaction.guild_id) + guild = session.scalar(stmt) + guild.VerificationChannel = channel_id + session.commit() await interaction.send(f"Registered <#{channel_id}>.", ephemeral=True) @group_output_channel.on_autocomplete("group_id") diff --git a/cogs/commands/views/update_username_verify.py b/cogs/commands/views/update_username_verify.py index b3d539c..8ff4ca4 100644 --- a/cogs/commands/views/update_username_verify.py +++ b/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: - embed_content = interaction.message.embeds[0].to_dict() - old_username: str = embed_content["fields"][0]["value"] - new_username: str = embed_content["fields"][1]["value"] + with Session(engine) as session: + try: + embed_content = interaction.message.embeds[0].to_dict() + 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) - category_ids: "list[int]" = list(session.scalars(stmt)) + stmt = select(distinct(Score.CategoryId)).where(Score.UserName == old_username) + category_ids: "list[int]" = list(session.scalars(stmt)) - stmt = select(Score).where(Score.UserName == old_username) - for score in session.scalars(stmt): - score.UserName = new_username - session.commit() + stmt = select(Score).where(Score.UserName == old_username) + for score in session.scalars(stmt): + score.UserName = new_username + 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): - await send_highscore_message(interaction.guild.get_channel(group.ChannelId), group) + for group in session.scalars(stmt): + await send_highscore_message(session, interaction.guild.get_channel(group.ChannelId), group) - content = interaction.message.content - content += f"\nApproved by <@{interaction.user.id}>." - await interaction.message.edit(content=content, embeds=interaction.message.embeds, view=None) - except exc.DataError: - session.rollback() - content = interaction.message.content - content += "\nError, UserName is too long." - 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) + content = interaction.message.content + content += f"\nApproved by <@{interaction.user.id}>." + await interaction.message.edit(content=content, embeds=interaction.message.embeds, view=None) + except exc.DataError: + session.rollback() + content = interaction.message.content + content += "\nError, UserName is too long." + 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) diff --git a/cogs/guild_listener/__init__.py b/cogs/guild_listener/__init__.py index de87bc4..965b17f 100644 --- a/cogs/guild_listener/__init__.py +++ b/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,9 +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() + + with Session(engine) as session: + 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") diff --git a/cogs/message_listener/__init__.py b/cogs/message_listener/__init__.py index 05c2bba..a1468d7 100644 --- a/cogs/message_listener/__init__.py +++ b/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 - if message.channel.id == submission_channel_id: - state = submission.submission_state - if state == SubmissionState.SCORE and message.content: + with Session(engine) as session: + 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) + ) - 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 - is_time_record = session.scalar(stmt) + stmt = select(Category.IsTimeRecord).where(Category.CategoryId == submission.category_id) - time_regex = re.search("^([0-9]{1,2}:[0-9]|[0-9])?[0-9](\\.[0-9])?$", message.content) - int_regex = re.search("^[0-9]+$", message.content) - if time_regex is None and is_time_record: - embeds = submission_message.embeds[0] - embeds.add_field( - name="Error", - value="Time record must follow format MM:SS.ms, SS.ms, or SS.", + # check with regex if score matches correctly + is_time_record = session.scalar(stmt) + + time_regex = re.search("^([0-9]{1,2}:[0-9]|[0-9])?[0-9](\\.[0-9])?$", message.content) + int_regex = re.search("^[0-9]+$", message.content) + if time_regex is None and is_time_record: + 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: - 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 + 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, - ) - 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 submission_message.edit( + embeds=embeds, + ) - await message.delete() + await message.delete() # This function will be called when this extension is loaded. diff --git a/cogs/submission/submission_views.py b/cogs/submission/submission_views.py index 08f7bf8..8954edf 100644 --- a/cogs/submission/submission_views.py +++ b/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) - stmt = select(Category).where(Category.GroupId == cat_group_alias.GroupId) - categories_list = session.scalars(stmt) - for category in categories_list: - options.append(nextcord.SelectOption(label=category.CategoryName, value=str(category.CategoryId))) + + with Session(engine) as session: + subq = select(CategoryGroup).where(CategoryGroup.GroupId == group_id).subquery() + cat_group_alias = aliased(CategoryGroup, subq) + stmt = select(Category).where(Category.GroupId == cat_group_alias.GroupId) + 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) - verification_channel_id = session.scalar(stmt) + with Session(engine) as session: + 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 = ( - select(CategoryGroup.GroupId) - .where(CategoryGroup.GuildId == interaction.guild_id) - .where(CategoryGroup.MessageId == interaction.message.id) - ) - group_id = session.scalar(stmt) + with Session(engine) as session: + stmt = ( + select(CategoryGroup.GroupId) + .where(CategoryGroup.GuildId == interaction.guild_id) + .where(CategoryGroup.MessageId == interaction.message.id) + ) + group_id = session.scalar(stmt) - stmt = select(Guild.SubmissionChannel).where(Guild.GuildId == interaction.guild_id) - channel = interaction.guild.get_channel(session.scalar(stmt)) + stmt = select(Guild.SubmissionChannel).where(Guild.GuildId == interaction.guild_id) + 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... diff --git a/highscores_compose.yaml b/docker-compose.yml similarity index 86% rename from highscores_compose.yaml rename to docker-compose.yml index 5bdade4..b4050eb 100644 --- a/highscores_compose.yaml +++ b/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: \ No newline at end of file + highscores_data: diff --git a/highscores.py b/highscores.py index b65fde3..224f7f5 100644 --- a/highscores.py +++ b/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") diff --git a/utilities/sql_alchemy_connection.py b/utilities/sql_data_classes.py similarity index 80% rename from utilities/sql_alchemy_connection.py rename to utilities/sql_data_classes.py index 40b5bb2..f3bd1fa 100644 --- a/utilities/sql_alchemy_connection.py +++ b/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 diff --git a/utilities/utils.py b/utilities/utils.py index 8c1c336..0a9fd31 100644 --- a/utilities/utils.py +++ b/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 - subq = ( - select(CategoryGroup) - .where(CategoryGroup.GuildId == guild_id) - .where(CategoryGroup.GroupId == group_id) - .subquery() - ) - cat_group_alias = aliased(CategoryGroup, subq) - stmt = select(Category).where(Category.GroupId == cat_group_alias.GroupId) - categories_dict: dict = {cat.CategoryName: str(cat.CategoryId) for cat in session.scalars(stmt)} + with Session(engine) as session: + # search database for all category names + subq = ( + select(CategoryGroup) + .where(CategoryGroup.GuildId == guild_id) + .where(CategoryGroup.GroupId == group_id) + .subquery() + ) + cat_group_alias = aliased(CategoryGroup, subq) + 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. - stmt = select(CategoryGroup).where(CategoryGroup.GuildId == guild_id) + with Session(engine) as session: + # Select all groups in guild. + stmt = select(CategoryGroup).where(CategoryGroup.GuildId == guild_id) - # 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)} + # 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)} # 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 - subq = ( - 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 + with Session(engine) as session: + # get all categories in the group subq = ( - select(Category) - .where(Category.GroupId == category_group.GroupId) - .where(Category.CategoryId == category_id) + select(CategoryGroup) + .where(CategoryGroup.GuildId == guild_id) + .where(CategoryGroup.GroupId == group_id) .subquery() ) - category = aliased(Category, subq) - stmt = select(distinct(Score.UserName)).where(Score.CategoryId == category.CategoryId) + category_group = aliased(CategoryGroup, subq) - 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)) - stmt = select(distinct(Score.UserName)).where(Score.CategoryId.in_(category_ids)) - users_list: "list[str]" = list(session.scalars(stmt)) + + with Session(engine) as session: + group_ids = select(CategoryGroup.GroupId).where(CategoryGroup.GuildId == guild_id) + 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,19 +298,23 @@ 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, channel: nextcord.TextChannel, group: CategoryGroup +) -> nextcord.Message: """ Function takes care of checking if a message exists for a group. Creates and sends/edits the message. Args: + session (Session): The sqlalchemy session being used for this function call. channel (nextcord.TextChannel): Discord channel object where message is sent group (CategoryGroup): group to post to the message Returns: nextcord.Message: Message object that was posted with group contents """ - highscore_string = format_highscore_message(group) + + highscore_string = format_highscore_message(session, group) try: message: nextcord.Message = await channel.fetch_message(group.MessageId) @@ -332,37 +343,38 @@ async def submit_score( score (str): Score to submit. Need to convert to correct type. """ - stmt = select(Category.IsTimeRecord).where(Category.CategoryId == category_id) - is_time_record = session.scalar(stmt) + with Session(engine) as session: + stmt = select(Category.IsTimeRecord).where(Category.CategoryId == category_id) + is_time_record = session.scalar(stmt) - if is_time_record: - minutes = float(score.split(":", maxsplit=1)[0]) - seconds = float(score.split(":", maxsplit=1)[1]) - score = (minutes * 60) + seconds - else: - score = float(score) + if is_time_record: + minutes = float(score.split(":", maxsplit=1)[0]) + seconds = float(score.split(":", maxsplit=1)[1]) + score = (minutes * 60) + seconds + else: + score = float(score) - stmt = select(Score).where(Score.UserName == username).where(Score.CategoryId == category_id) - existing_score = session.scalar(stmt) + stmt = select(Score).where(Score.UserName == username).where(Score.CategoryId == category_id) + existing_score = session.scalar(stmt) - if existing_score: - existing_score.Score = score - else: - score_obj = Score(UserName=username, Score=score, CategoryId=category_id) - session.add(score_obj) - session.commit() + if existing_score: + existing_score.Score = score + else: + score_obj = Score(UserName=username, Score=score, CategoryId=category_id) + session.add(score_obj) + session.commit() - stmt = select(CategoryGroup).where(CategoryGroup.GroupId == group_id) - group = session.scalar(stmt) + stmt = select(CategoryGroup).where(CategoryGroup.GroupId == group_id) + group = session.scalar(stmt) - # edit message - channel = interaction.guild.get_channel(group.ChannelId) + # edit message + 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) + 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) + await send_highscore_message(session, channel, group) def add_preset_configuration(guild_id: int, config_str: str) -> None: @@ -374,19 +386,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(): - 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) + with Session(engine) as session: + with open(f"example_config/{config_str}.json", encoding="utf-8", mode="r") as file: + config = json.load(file) - 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() From a9920db381ae874f9bd07366caf648003a5dec27 Mon Sep 17 00:00:00 2001 From: alwayscompiling Date: Wed, 7 Dec 2022 20:54:49 -0500 Subject: [PATCH 03/12] Don't auto add runescape groups on join. --- cogs/guild_listener/__init__.py | 2 -- 1 file changed, 2 deletions(-) diff --git a/cogs/guild_listener/__init__.py b/cogs/guild_listener/__init__.py index 965b17f..5846b4d 100644 --- a/cogs/guild_listener/__init__.py +++ b/cogs/guild_listener/__init__.py @@ -26,8 +26,6 @@ class GuildListener(commands.Cog, name="Guild Listener"): with Session(engine) as session: 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!" welcome_message += " Currently only supporting RuneScape boss highscores," From 6c5f40f788ac2117a0b4443dde5cd32d8125463f Mon Sep 17 00:00:00 2001 From: alwayscompiling Date: Wed, 7 Dec 2022 21:37:16 -0500 Subject: [PATCH 04/12] Refractor command files into single command files. --- cogs/commands/__init__.py | 10 +- .../{data_management.py => delete.py} | 115 ++++++++++-------- .../{message_management.py => refresh.py} | 110 +++++------------ cogs/commands/update.py | 84 +++++++++++++ 4 files changed, 185 insertions(+), 134 deletions(-) rename cogs/commands/{data_management.py => delete.py} (80%) rename cogs/commands/{message_management.py => refresh.py} (55%) create mode 100644 cogs/commands/update.py diff --git a/cogs/commands/__init__.py b/cogs/commands/__init__.py index 79a9734..b1422cd 100644 --- a/cogs/commands/__init__.py +++ b/cogs/commands/__init__.py @@ -5,9 +5,10 @@ Cog loader. Adds all command cogs to the bot. from nextcord.ext import commands # Command classes -from .data_management import DataManagementCog -from .message_management import MessageManagementCog +from .delete import DeleteCog +from .refresh import RefreshCog from .set import SetCog +from .update import UpdateCog # This function will be called when this extension is loaded. @@ -16,6 +17,7 @@ def setup(bot: commands.Bot): """ Adds all command classes to bot. """ - bot.add_cog(DataManagementCog(bot)) - bot.add_cog(MessageManagementCog(bot)) + bot.add_cog(DeleteCog()) + bot.add_cog(RefreshCog(bot)) bot.add_cog(SetCog()) + bot.add_cog(UpdateCog(bot)) diff --git a/cogs/commands/data_management.py b/cogs/commands/delete.py similarity index 80% rename from cogs/commands/data_management.py rename to cogs/commands/delete.py index 223d809..a96a6ed 100644 --- a/cogs/commands/data_management.py +++ b/cogs/commands/delete.py @@ -1,5 +1,5 @@ """ -Commands for managing the tables/categories/scores for a Guild. +Commands for deleting groups/categories/scores in database and messages in discord.. """ from typing import Optional @@ -10,7 +10,7 @@ from sqlalchemy import distinct, select from sqlalchemy.orm import Session # pylint: disable=import-error -from utilities.sql_data_classes import Category, CategoryGroup, Guild, Score, engine +from utilities.sql_data_classes import Category, CategoryGroup, Score, engine from utilities.utils import ( autofill_categories, autofill_groups, @@ -19,26 +19,16 @@ from utilities.utils import ( send_highscore_message, ) -from .views.update_username_verify import UpdateUsernameVerifyView - -class DataManagementCog(commands.Cog, name="Table Management"): +class DeleteCog(commands.Cog, name="Table Management"): """ - Class holds commands for managing the data storage of the highscores. + Class holds commands for deleting. """ - def __init__(self, bot: commands.Bot): + def __init__(self) -> None: """ - Default constructor for DataManagement class. Sets internal bot variable. + Default constructor for DeleteCog 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): @@ -47,15 +37,60 @@ class DataManagementCog(commands.Cog, name="Table Management"): """ @delete.subcommand() - async def user(self, interaction: nextcord.Interaction): + async def all(self, interaction: nextcord.Interaction): """ - Subcommand parent for deleting user information. Never called. + Subcommand parent for deleting everything in a group. Never called. """ - @user.subcommand( + @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 from_all( + async def users( self, interaction: nextcord.Interaction, user_name: str = nextcord.SlashOption( @@ -89,6 +124,12 @@ class DataManagementCog(commands.Cog, name="Table Management"): await interaction.send(f'User "{user_name}" was removed from all tables.', ephemeral=True) + @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, @@ -205,39 +246,7 @@ class DataManagementCog(commands.Cog, name="Table Management"): ) ) - @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. - """ - - 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) - - @update_username.on_autocomplete("old_username") - @from_all.on_autocomplete("user_name") + @users.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. diff --git a/cogs/commands/message_management.py b/cogs/commands/refresh.py similarity index 55% rename from cogs/commands/message_management.py rename to cogs/commands/refresh.py index bbbb870..62ea32b 100644 --- a/cogs/commands/message_management.py +++ b/cogs/commands/refresh.py @@ -1,9 +1,7 @@ """ -Commands for managing/displaying the highscores messages. +Commands for refreshing highscore messages. """ -from typing import Optional - import nextcord from nextcord.ext import commands from sqlalchemy import select @@ -15,73 +13,63 @@ from utilities.sql_data_classes import CategoryGroup, engine from utilities.utils import autofill_groups, send_highscore_message -class MessageManagementCog(commands.Cog, name="Message Management"): +class RefreshCog(commands.Cog, name="Refresh Cog"): """ - Class holds commands for managing the messages that display highscores. + Class holds commands for refreshing. """ def __init__(self, bot: commands.Bot) -> None: """ - Default constructor for MessageManagement class + Default constructor for RefreshCog class Args: bot (commands.Bot): Bot object. Required to register submission button view. """ - self.bot = bot + 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( + @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, - channel: Optional[nextcord.abc.GuildChannel] = nextcord.SlashOption( - description="Channel to clear of messages.", - required=False, - channel_types=[nextcord.ChannelType.text], - default=None, - ), + group_id: str = nextcord.SlashOption(name="group", description="Name of Group.", required=True), ) -> 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. + Refreshes a table given by user. 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. + interaction (nextcord.Interaction): Interaction that invoked the command. + group_id (str): Str representation of Group id to refresh. Is SlashOption. """ - 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) + .where(CategoryGroup.GroupId == int(group_id)) ) - # TODO test when nothing in channel - groups = session.scalars(stmt) + group = session.scalar(stmt) - await interaction.response.defer(ephemeral=True) + channel = interaction.guild.get_channel(group.ChannelId) - 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 + message: nextcord.Message = await send_highscore_message(session, channel, group) + await message.edit(view=SubmissionCreateButton(self._bot)) - await interaction.send("Table messages deleted.", ephemeral=True) + await interaction.response.send_message(f"Updated table {group.GroupName}!", 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: + @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. @@ -108,43 +96,11 @@ class MessageManagementCog(commands.Cog, name="Message Management"): assert channel is not None, await interaction.response(error_response, ephemeral=True) message: nextcord.Message = await send_highscore_message(session, channel, group) - await message.edit(view=SubmissionCreateButton(self.bot)) + 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. - """ - - with Session(engine) as session: - 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(session, 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") + @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. diff --git a/cogs/commands/update.py b/cogs/commands/update.py new file mode 100644 index 0000000..b1531d0 --- /dev/null +++ b/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 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)) From 91e57c6555febab041e5d78a0803ba6f6a442e10 Mon Sep 17 00:00:00 2001 From: alwayscompiling Date: Wed, 7 Dec 2022 21:52:36 -0500 Subject: [PATCH 05/12] Standardize autocomplete function names. --- cogs/commands/delete.py | 10 +++++----- cogs/commands/refresh.py | 2 +- cogs/commands/set.py | 2 +- cogs/commands/update.py | 2 +- 4 files changed, 8 insertions(+), 8 deletions(-) diff --git a/cogs/commands/delete.py b/cogs/commands/delete.py index a96a6ed..0634180 100644 --- a/cogs/commands/delete.py +++ b/cogs/commands/delete.py @@ -27,7 +27,7 @@ class DeleteCog(commands.Cog, name="Table Management"): def __init__(self) -> None: """ - Default constructor for DeleteCog class. Sets internal bot variable. + Default constructor for DeleteCog class. """ @nextcord.slash_command(default_member_permissions=nextcord.Permissions(administrator=True)) @@ -201,7 +201,7 @@ class DeleteCog(commands.Cog, name="Table Management"): @from_category.on_autocomplete("group_id") @from_group.on_autocomplete("group_id") - async def autocomplete_group(self, interaction: nextcord.Interaction, group_id: str): + async def group_autocomplete(self, interaction: nextcord.Interaction, group_id: str): """ Autocomplete function for table names. @@ -212,7 +212,7 @@ class DeleteCog(commands.Cog, name="Table Management"): 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): + async def category_autocomplete(self, interaction: nextcord.Interaction, category_id: str, group_id: str): """ Autocomplete function for category names. @@ -227,7 +227,7 @@ class DeleteCog(commands.Cog, name="Table Management"): @from_category.on_autocomplete("user_name") @from_group.on_autocomplete("user_name") - async def autocomplete_user( + async def user_autocomplete( self, interaction: nextcord.Interaction, user_name: str, group_id: str, category_id: Optional[str] = None ): """ @@ -247,7 +247,7 @@ class DeleteCog(commands.Cog, name="Table Management"): ) @users.on_autocomplete("user_name") - async def username_autofill(self, interaction: nextcord.Interaction, username: str): + 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. diff --git a/cogs/commands/refresh.py b/cogs/commands/refresh.py index 62ea32b..c0ddb12 100644 --- a/cogs/commands/refresh.py +++ b/cogs/commands/refresh.py @@ -101,7 +101,7 @@ class RefreshCog(commands.Cog, name="Refresh Cog"): await interaction.send(f"Posted all groups in {interaction.guild.name}'s highscores.", ephemeral=True) @group.on_autocomplete("group_id") - async def refresh_table_autofill(self, interaction: nextcord.Interaction, group_id: str): + 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. diff --git a/cogs/commands/set.py b/cogs/commands/set.py index 7f65318..bca49c1 100644 --- a/cogs/commands/set.py +++ b/cogs/commands/set.py @@ -193,7 +193,7 @@ class SetCog(commands.Cog, name="Set command."): @group_output_channel.on_autocomplete("group_id") @category_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. diff --git a/cogs/commands/update.py b/cogs/commands/update.py index b1531d0..201de09 100644 --- a/cogs/commands/update.py +++ b/cogs/commands/update.py @@ -73,7 +73,7 @@ class UpdateCog(commands.Cog, name="Update commands."): await interaction.send("Request sent to admins for verification.", ephemeral=True) @username.on_autocomplete("old_username") - async def username_autofill(self, interaction: nextcord.Interaction, username: str): + 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. From 88cec73644155318a7ef5ce449f52b5c6ea42758 Mon Sep 17 00:00:00 2001 From: alwayscompiling Date: Wed, 7 Dec 2022 22:24:38 -0500 Subject: [PATCH 06/12] Create command skeletons. Update set to conform to min and max values decided in create. --- cogs/commands/__init__.py | 3 +- cogs/commands/create.py | 87 +++++++++++++++++++++++++++++++++++++++ cogs/commands/set.py | 80 +++++++++++++++++++---------------- 3 files changed, 133 insertions(+), 37 deletions(-) create mode 100644 cogs/commands/create.py diff --git a/cogs/commands/__init__.py b/cogs/commands/__init__.py index b1422cd..040236b 100644 --- a/cogs/commands/__init__.py +++ b/cogs/commands/__init__.py @@ -4,7 +4,7 @@ Cog loader. Adds all command cogs to the bot. from nextcord.ext import commands -# Command classes +from .create import CreateCog from .delete import DeleteCog from .refresh import RefreshCog from .set import SetCog @@ -17,6 +17,7 @@ def setup(bot: commands.Bot): """ Adds all command classes to bot. """ + bot.add_cog(CreateCog()) bot.add_cog(DeleteCog()) bot.add_cog(RefreshCog(bot)) bot.add_cog(SetCog()) diff --git a/cogs/commands/create.py b/cogs/commands/create.py new file mode 100644 index 0000000..2a87b58 --- /dev/null +++ b/cogs/commands/create.py @@ -0,0 +1,87 @@ +""" +Commands for creating items in bot. +""" + +from typing import Optional + +import nextcord +from nextcord.ext import commands + +# pylint: disable=import-error +from utilities.utils import autofill_groups, MAX_LINE_LENGTH + + +class CreateCog(commands.Cog, name="Create Cog"): + """ + Class holds commands for creating things. + """ + + def __init__(self) -> None: + """ + Default constructor for CreateCog class. + """ + + @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. + """ + + @create.subcommand(description="Create a new category. Must not exist already in CategoryGroup.") + 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: + pass + + @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 alloted to a category. 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, + minvalue=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: + pass + + @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)) diff --git a/cogs/commands/set.py b/cogs/commands/set.py index bca49c1..f3c6ea5 100644 --- a/cogs/commands/set.py +++ b/cogs/commands/set.py @@ -11,7 +11,7 @@ from sqlalchemy.orm import Session # pylint: disable=import-error from utilities.sql_data_classes import CategoryGroup, Guild, engine -from utilities.utils import autofill_groups +from utilities.utils import autofill_groups, MAX_LINE_LENGTH class SetCog(commands.Cog, name="Set command."): @@ -30,39 +30,6 @@ class SetCog(commands.Cog, name="Set command."): 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. - """ - - 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 a Category Group's messages.") async def group_output_channel( self, @@ -101,6 +68,45 @@ class SetCog(commands.Cog, name="Set command."): session.commit() await interaction.send(f"Registered <#{channel_id}>.", ephemeral=True) + @set.subcommand( + 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, @@ -139,7 +145,9 @@ class SetCog(commands.Cog, name="Set command."): 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), + 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. @@ -191,7 +199,7 @@ class SetCog(commands.Cog, name="Set command."): await interaction.send(f"Registered <#{channel_id}>.", 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_autocomplete(self, interaction: nextcord.Interaction, group_id: str): """ From a9b889234aba54a2a4fd8c53a5f25ef3438cc0fb Mon Sep 17 00:00:00 2001 From: alwayscompiling Date: Wed, 7 Dec 2022 22:40:47 -0500 Subject: [PATCH 07/12] Start filling out create category. --- cogs/commands/create.py | 34 +++++++++++++++++++++++++++++++--- cogs/commands/set.py | 2 +- 2 files changed, 32 insertions(+), 4 deletions(-) diff --git a/cogs/commands/create.py b/cogs/commands/create.py index 2a87b58..ce6f893 100644 --- a/cogs/commands/create.py +++ b/cogs/commands/create.py @@ -6,9 +6,12 @@ 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.utils import autofill_groups, MAX_LINE_LENGTH +from utilities.sql_data_classes import Category, CategoryGroup, engine +from utilities.utils import MAX_LINE_LENGTH, autofill_groups class CreateCog(commands.Cog, name="Create Cog"): @@ -44,7 +47,29 @@ class CreateCog(commands.Cog, name="Create Cog"): description="How many scores to post in Category. Default is 3.", required=False, default=3, min_value=1 ), ) -> None: - pass + + new_category = Category( + CategoryName=category_name, + GroupId=int(group_id), + Size=size, + IsAscending=is_ascending, + IsTimeRecord=is_time_record, + IsValidated=is_validated, + ) + + with Session(engine) as session: + try: + session.add(new_category) + session.commit() + # TODO get correct exception + except Exception as ece: + # Category name already exists in group + print(ece) + session.rollback() + stmt = select(CategoryGroup.GroupName).where(CategoryGroup.GroupId == int(group_id)) + interaction.response.send_message( + f"{category_name} already exists in {session.scalar(stmt)}. Please rename.", ephemeral=True + ) @create.subcommand(description="Create a new Category Group. Must not exist already for Guild.") async def group( @@ -72,7 +97,10 @@ class CreateCog(commands.Cog, name="Create Cog"): default=None, ), ) -> None: - pass + + # if no channel provided, use current channel. + if channel is None: + channel = interaction.channel @category.on_autocomplete("group_id") async def group_autocomplete(self, interaction: nextcord.Interaction, group_id: str): diff --git a/cogs/commands/set.py b/cogs/commands/set.py index f3c6ea5..82e738b 100644 --- a/cogs/commands/set.py +++ b/cogs/commands/set.py @@ -11,7 +11,7 @@ from sqlalchemy.orm import Session # pylint: disable=import-error from utilities.sql_data_classes import CategoryGroup, Guild, engine -from utilities.utils import autofill_groups, MAX_LINE_LENGTH +from utilities.utils import MAX_LINE_LENGTH, autofill_groups class SetCog(commands.Cog, name="Set command."): From f468a028d00c6a5bc3a9ef40eee52a637e3075ab Mon Sep 17 00:00:00 2001 From: alwayscompiling Date: Thu, 8 Dec 2022 13:01:57 -0500 Subject: [PATCH 08/12] Changed send_highscore_message to take guild rather than channel. --- cogs/commands/delete.py | 6 +++--- cogs/commands/refresh.py | 13 ++---------- cogs/commands/views/update_username_verify.py | 2 +- utilities/utils.py | 20 ++++++------------- 4 files changed, 12 insertions(+), 29 deletions(-) diff --git a/cogs/commands/delete.py b/cogs/commands/delete.py index 0634180..44d3622 100644 --- a/cogs/commands/delete.py +++ b/cogs/commands/delete.py @@ -120,7 +120,7 @@ class DeleteCog(commands.Cog, name="Table Management"): stmt = select(CategoryGroup).where(CategoryGroup.GroupId.in_(group_ids)) for group in session.scalars(stmt): - await send_highscore_message(session, interaction.guild.get_channel(group.ChannelId), group) + await send_highscore_message(session, interaction.guild, group) await interaction.send(f'User "{user_name}" was removed from all tables.', ephemeral=True) @@ -163,7 +163,7 @@ class DeleteCog(commands.Cog, name="Table Management"): session.delete(session.scalar(stmt)) session.commit() - await send_highscore_message(session, interaction.guild.get_channel(group.ChannelId), group) + await send_highscore_message(session, interaction.guild, group) await interaction.response.send_message( f'User "{user_name}" removed from "{category_name}".', ephemeral=True ) @@ -194,7 +194,7 @@ class DeleteCog(commands.Cog, name="Table Management"): session.delete(score) session.commit() - await send_highscore_message(session, interaction.guild.get_channel(group.ChannelId), group) + 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 ) diff --git a/cogs/commands/refresh.py b/cogs/commands/refresh.py index c0ddb12..aae54a6 100644 --- a/cogs/commands/refresh.py +++ b/cogs/commands/refresh.py @@ -55,9 +55,7 @@ class RefreshCog(commands.Cog, name="Refresh Cog"): ) group = session.scalar(stmt) - channel = interaction.guild.get_channel(group.ChannelId) - - message: nextcord.Message = await send_highscore_message(session, channel, group) + 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) @@ -88,14 +86,7 @@ class RefreshCog(commands.Cog, name="Refresh Cog"): 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(session, channel, group) + 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) diff --git a/cogs/commands/views/update_username_verify.py b/cogs/commands/views/update_username_verify.py index 8ff4ca4..84b2fcf 100644 --- a/cogs/commands/views/update_username_verify.py +++ b/cogs/commands/views/update_username_verify.py @@ -63,7 +63,7 @@ class UpdateUsernameVerifyView(nextcord.ui.View): stmt = select(CategoryGroup).where(CategoryGroup.GroupId.in_(group_ids)) for group in session.scalars(stmt): - await send_highscore_message(session, interaction.guild.get_channel(group.ChannelId), group) + await send_highscore_message(session, interaction.guild, group) content = interaction.message.content content += f"\nApproved by <@{interaction.user.id}>." diff --git a/utilities/utils.py b/utilities/utils.py index 0a9fd31..dc82ef4 100644 --- a/utilities/utils.py +++ b/utilities/utils.py @@ -298,23 +298,22 @@ def get_time_str(time_in: float) -> str: return time.strftime(f"%-M:%S.{milliseconds}", time.gmtime(time_in)) -async def send_highscore_message( - session: Session, 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: session (Session): The sqlalchemy session being used for this function call. - channel (nextcord.TextChannel): Discord channel object where message is sent - 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(session, group) + channel = guild.get_channel(group.ChannelId) try: message: nextcord.Message = await channel.fetch_message(group.MessageId) @@ -367,14 +366,7 @@ async def submit_score( stmt = select(CategoryGroup).where(CategoryGroup.GroupId == group_id) group = session.scalar(stmt) - # edit message - 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(session, channel, group) + await send_highscore_message(session, interaction.guild, group) def add_preset_configuration(guild_id: int, config_str: str) -> None: From dace72f5cc6c0115902665716900a89ca305c2f6 Mon Sep 17 00:00:00 2001 From: alwayscompiling Date: Thu, 8 Dec 2022 13:28:13 -0500 Subject: [PATCH 09/12] Correct empty message id handling. --- utilities/utils.py | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/utilities/utils.py b/utilities/utils.py index dc82ef4..be41bbb 100644 --- a/utilities/utils.py +++ b/utilities/utils.py @@ -315,14 +315,14 @@ async def send_highscore_message(session: Session, guild: nextcord.Guild, group: highscore_string = format_highscore_message(session, group) channel = guild.get_channel(group.ChannelId) - try: - message: nextcord.Message = await channel.fetch_message(group.MessageId) - 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 From 93248797a0795e8ad22ccfd20e47307d60a92ce7 Mon Sep 17 00:00:00 2001 From: alwayscompiling Date: Thu, 8 Dec 2022 13:41:15 -0500 Subject: [PATCH 10/12] Fill out rest of group and category command. Fill out doc strings. --- cogs/commands/create.py | 76 +++++++++++++++++++++++++++++++++++------ 1 file changed, 65 insertions(+), 11 deletions(-) diff --git a/cogs/commands/create.py b/cogs/commands/create.py index ce6f893..dd7d94c 100644 --- a/cogs/commands/create.py +++ b/cogs/commands/create.py @@ -6,12 +6,12 @@ from typing import Optional import nextcord from nextcord.ext import commands -from sqlalchemy import select +from sqlalchemy import select, exc from sqlalchemy.orm import Session # pylint: disable=import-error from utilities.sql_data_classes import Category, CategoryGroup, engine -from utilities.utils import MAX_LINE_LENGTH, autofill_groups +from utilities.utils import MAX_LINE_LENGTH, autofill_groups, send_highscore_message class CreateCog(commands.Cog, name="Create Cog"): @@ -30,7 +30,9 @@ class CreateCog(commands.Cog, name="Create Cog"): Parent slash command for creating things. Never called. """ - @create.subcommand(description="Create a new category. Must not exist already in CategoryGroup.") + # 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, @@ -47,6 +49,19 @@ class CreateCog(commands.Cog, name="Create Cog"): 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, @@ -57,27 +72,33 @@ class CreateCog(commands.Cog, name="Create Cog"): 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() - # TODO get correct exception - except Exception as ece: + 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 - print(ece) session.rollback() - stmt = select(CategoryGroup.GroupName).where(CategoryGroup.GroupId == int(group_id)) - interaction.response.send_message( - f"{category_name} already exists in {session.scalar(stmt)}. Please rename.", ephemeral=True + 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 alloted to a category. Default is 26.", + description="Number of characters wide a category is printed. Default is 26.", required=False, default=26, min_value=7, @@ -87,7 +108,7 @@ class CreateCog(commands.Cog, name="Create Cog"): description="Number of characters of a username to display. Default is 12.", required=False, default=12, - minvalue=1, + min_value=1, max_value=30, ), channel: Optional[nextcord.abc.GuildChannel] = nextcord.SlashOption( @@ -97,11 +118,44 @@ class CreateCog(commands.Cog, name="Create Cog"): 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() + await send_highscore_message(session, interaction.guild, new_group) + 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): """ From 8952c4a35265e08ab47d872d80b771c037fc13cd Mon Sep 17 00:00:00 2001 From: alwayscompiling Date: Thu, 8 Dec 2022 13:44:34 -0500 Subject: [PATCH 11/12] Remove onjoin message. --- cogs/guild_listener/__init__.py | 7 ------- 1 file changed, 7 deletions(-) diff --git a/cogs/guild_listener/__init__.py b/cogs/guild_listener/__init__.py index 5846b4d..164a55b 100644 --- a/cogs/guild_listener/__init__.py +++ b/cogs/guild_listener/__init__.py @@ -27,13 +27,6 @@ class GuildListener(commands.Cog, name="Guild Listener"): session.add(new_guild) session.commit() - welcome_message: str = "Hello, I keep track of Highscores for you!" - welcome_message += " Currently only supporting RuneScape boss highscores," - welcome_message += " but will be more dynamic support in future." - 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. # It is necessary to add these functions to the bot. From 411f8ab275fc19676db632a112aad97fd5909baa Mon Sep 17 00:00:00 2001 From: alwayscompiling Date: Thu, 8 Dec 2022 22:59:00 -0500 Subject: [PATCH 12/12] Add a deletion confirmation. --- cogs/commands/delete.py | 41 ++++++++++- cogs/commands/views/delete_confirm.py | 97 +++++++++++++++++++++++++++ 2 files changed, 137 insertions(+), 1 deletion(-) create mode 100644 cogs/commands/views/delete_confirm.py diff --git a/cogs/commands/delete.py b/cogs/commands/delete.py index 44d3622..2c7af4d 100644 --- a/cogs/commands/delete.py +++ b/cogs/commands/delete.py @@ -19,6 +19,8 @@ from utilities.utils import ( send_highscore_message, ) +from .views.delete_confirm import DeleteConfirmView, create_delete_id + class DeleteCog(commands.Cog, name="Table Management"): """ @@ -39,7 +41,7 @@ class DeleteCog(commands.Cog, name="Table Management"): @delete.subcommand() async def all(self, interaction: nextcord.Interaction): """ - Subcommand parent for deleting everything in a group. Never called. + Subcommand parent for deleting all of a thing. Never called. """ @all.subcommand(description="Clears highscores channel of all table messages. Does not change data.") @@ -124,6 +126,40 @@ class DeleteCog(commands.Cog, name="Table Management"): 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): """ @@ -201,6 +237,8 @@ class DeleteCog(commands.Cog, name="Table Management"): @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. @@ -212,6 +250,7 @@ class DeleteCog(commands.Cog, name="Table Management"): 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. diff --git a/cogs/commands/views/delete_confirm.py b/cogs/commands/views/delete_confirm.py new file mode 100644 index 0000000..0296013 --- /dev/null +++ b/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