"""Contains command for submitting a score.""" import re import nextcord from nextcord.ext import commands from sqlalchemy import select from sqlalchemy.orm import Session from sqlmodel import col from cogs.submission.verification_view import VerificationView from database.db import engine from database.models import Category, CategoryGroup, Guild, Submission from main import agon_logger from utilities.utils import autofill_categories, autofill_groups, submit_score class SubmissionCog(commands.Cog): """Class holds command for submitting a score.""" def __init__(self) -> None: return # TODO(imcompiling): fix too many return statements when reworking command. # https://gitea.cheezers.org/imcompiling/agon/issues/76 @nextcord.slash_command() async def submit( # noqa: PLR0911, PLR0913 self, interaction: nextcord.Interaction, group_id: str = nextcord.SlashOption(name="group", required=True, description="Group to submit score to."), category_id: str = nextcord.SlashOption( name="category", required=True, description="Category to submit score to." ), score: str = nextcord.SlashOption(required=True, description="Score to submit"), proof: nextcord.Attachment = nextcord.SlashOption( required=False, description="Proof for submission. Only needed if score requires verification." ), username: str = nextcord.SlashOption( required=False, description="Modified username if submitting under not your discord name." ), ) -> None: """ Submit a highscore. Sets the username if one isn't passed in. Checks if a submission needs verified. Ensures that the score is following the correct format. Then either creates the verification request or submits score if verification isn't required. Args: interaction (nextcord.Interaction): Interaction of the command. group_id (str): Is SlashOption. Group that the score category belongs in. category_id (str): Is SlashOption. Category to submit the score in. score (str): Is SlashOption. The score. proof (nextcord.Attachment): Is SlashOption. Picture to provide proof of score. username (str, optional): Is SlashOption. Username to associate with the score. """ # fill out username if not passed in if username is None: username = interaction.user.display_name with Session(engine) as session: stmt = ( select(Category) .where(col(Category.group_id) == int(group_id)) .where(col(Category.id) == int(category_id)) ) if (category := session.scalar(stmt)) is None: await interaction.response.send_message("Category not found.", ephemeral=True) return # check if verification is required. if no picture, deny if category.is_validated and proof is None: await interaction.response.send_message( "This category required verification. Please attach a picture and re-submit.", ephemeral=True ) return # check with regex if score is in correct format # check if verify_score was successful. It replies with corrections required itself. if ( verified_score := await self.verify_score(interaction, score, is_time_record=category.is_time_record) ) is None: # This response message will be filled out better once command is split up to # know which type it expects... await interaction.response.send_message("Format was incorrect.", ephemeral=True) return # Create submission verification request or submit score if verification not needed. if not category.is_validated: await submit_score(interaction, int(group_id), int(category_id), username, verified_score) await interaction.response.send_message("Score has been submitted!", ephemeral=True) return stmt = select(col(Guild.verification_channel)).where(col(Guild.id) == interaction.guild_id) if (verification_channel_id := session.scalar(stmt)) is None: error_response = "No verification channel was registered. Contact server admins." await interaction.response.send_message(error_response, ephemeral=True) return if (channel := interaction.guild.get_channel(verification_channel_id)) is None: error_response = "Registered Verification channel does not exist. Contact server admins." await interaction.response.send_message(error_response, ephemeral=True) return if not isinstance(channel, nextcord.TextChannel): await interaction.response.send_message("An error happened with submission.") agon_logger.error( "Channel id %s in guild %s is does not correspond to a TextChannel.", channel.id, channel.guild.id ) return # Send the verification message to admins verification_message = await channel.send( file=await proof.to_file(), view=VerificationView(), embeds=[self.create_embed(interaction, group_id, category_id, verified_score, username, session)], content=f"Submission from <@{interaction.user.id}>.", ) await interaction.response.send_message(content="Score submitted!", ephemeral=True) # Save the submission data for later use. submission: Submission = Submission( category_id=int(category_id), group_id=int(group_id), guild_id=interaction.guild_id, message_id=verification_message.id, score=verified_score, user_id=interaction.user.id, username=username, ) session.add(submission) session.commit() def create_embed( # noqa: PLR0913 self, interaction: nextcord.Interaction, group_id: str, category_id: str, score: str, username: str, session: Session, ) -> nextcord.Embed: """ Creates an embed containing submission data for human verification. Args: interaction (nextcord.Interaction): Discord interaction of the command. group_id (str): Used to get group name. category_id (str): Used to get category name. score (str): Score to set. username (str): Username to set. session (Session): Open connection to database. Returns: nextcord.Embed: Embed containing human readable submission data. """ embed = nextcord.Embed(title="Highscores Submission", description="Review fields and accept.") embed.add_field(name="User Name", value=username, inline=False) # Get group name from database stmt = ( select(col(CategoryGroup.name)) .where(col(CategoryGroup.guild_id) == interaction.guild_id) .where(col(CategoryGroup.id) == group_id) ) embed.add_field(name="Group", value=session.scalar(stmt), inline=False) # Get category name from database stmt = ( select(col(Category.name)).where(col(Category.group_id) == group_id).where(col(Category.id) == category_id) ) embed.add_field(name="Category", value=session.scalar(stmt), inline=False) embed.add_field(name="Score", value=score, inline=False) return embed async def verify_score(self, interaction: nextcord.Interaction, score: str, *, is_time_record: bool) -> str | None: """ Uses regex to verify that scores are in the correct format. Handles responding to the interaction if the format is incorrect. Also standardizes the time record. Args: interaction (nextcord.Interaction): Discord interaction of the command. score (str): String representation of the score being verified. is_time_record (bool): Whether the score needs to be verified/formatted as a time record. Returns: str | None: String of corrected score. None if formatted incorrectly. """ time_regex = re.search("^([0-9]{1,2}:[0-9]|[0-9])?[0-9](\\.[0-9])?$", score) int_regex = re.search("^[0-9]+$", score) if time_regex is None and is_time_record: await interaction.response.send_message( "Time record must follow format MM:SS.ms, SS.ms, or SS.", ephemeral=True ) return None if int_regex is None and not is_time_record: await interaction.response.send_message("Number record must only be number.", ephemeral=True) return None 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") return score @submit.on_autocomplete("group_id") async def group_autocomplete(self, interaction: nextcord.Interaction, group_id: str) -> None: """ Autocomplete function for group names. Args: interaction (nextcord.Interaction): Interaction that invoked the command. group_id (str): String to be autocompleted with Group name. """ await interaction.response.send_autocomplete(autofill_groups(interaction.guild_id, group_id)) @submit.on_autocomplete("category_id") async def category_autocomplete(self, interaction: nextcord.Interaction, category_id: str, group_id: str) -> None: """ Autocomplete function for category names. Args: interaction (nextcord.Interaction): Interaction that invoked the command. category_id (str): String to be autocompleted with Category name. group_id (str): Group to find Category from. """ await interaction.response.send_autocomplete( autofill_categories(interaction.guild_id, int(group_id), category_id) )