Rename main file to agon.

.gitea/workflows/build_develop.yml

@@ -1,20 +0,0 @@
-name: build_develop
-
-on:
-  push:
-    branches: [main]
-
-jobs:
-  build:
-    runs-on: ubuntu-latest
-    steps:
-      - name: Checkout Code
-        uses: actions/checkout@v3
-        with:
-          fetch-depth: 0
-      - name: Install Docker
-        uses: https://github.com/papodaca/install-docker-action@v1
-      - name: Build Docker Image
-        run: docker build -t viker.cheezers.net:5000/agon:develop .
-      - name: Push Docker Image
-        run: docker push viker.cheezers.net:5000/agon:develop

.gitea/workflows/build_release.yml

@@ -1,24 +0,0 @@
-name: build_release
-
-on:
-  push:
-    tags: ["v[0-9].[0-9].[0-9]"]
-
-jobs:
-  build:
-    runs-on: ubuntu-latest
-    steps:
-      - name: Checkout Code
-        uses: actions/checkout@v3
-        with:
-          fetch-depth: 0
-      - name: Install Docker
-        uses: https://github.com/papodaca/install-docker-action@v1
-      - name: Set env
-        run: echo "GIT_TAG=${GITHUB_REF#refs/*/}" >> $GITHUB_ENV
-      - name: Build Docker Images
-        run: docker build -t viker.cheezers.net:5000/agon:latest -t viker.cheezers.net:5000/agon:${{env.GIT_TAG}} .
-      - name: Push Latest Image
-        run: docker push viker.cheezers.net:5000/agon:latest
-      - name: Push Tagged Image
-        run: docker push viker.cheezers.net:5000/agon:${{env.GIT_TAG}}

agon.py

@@ -1,5 +1,5 @@
 """
-main file for highscores bot
+main file for agon
 """
 
 import logging

cogs/commands/__init__.py

@@ -10,7 +10,6 @@ from .help import HelpCog
 from .refresh import RefreshCog
 from .set import SetCog
 from .update import UpdateCog
-from .view import ViewCog
 
 
 # This function will be called when this extension is loaded.
@@ -25,4 +24,3 @@ def setup(bot: commands.Bot):
     bot.add_cog(RefreshCog(bot))
     bot.add_cog(SetCog())
     bot.add_cog(UpdateCog(bot))
-    bot.add_cog(ViewCog())

cogs/commands/view.py

@@ -1,112 +0,0 @@
-"""
-View command heirarchy.
-"""
-
-import nextcord
-import pandas as pd
-from nextcord.ext import commands
-from sqlalchemy import select
-from sqlalchemy.orm import Session
-
-# pylint: disable=import-error
-from utilities.sql_data_classes import Category, CategoryGroup, Score, engine
-from utilities.utils import MAX_LINE_LENGTH, autofill_categories, autofill_groups, format_score_string
-
-
-class ViewCog(commands.Cog, name="View Command"):
-    """
-    Class holds commands for viewing data.
-    """
-
-    def __init__(self) -> None:
-        """
-        Default constructor for ViewCog class. Does nothing.
-        """
-
-    @nextcord.slash_command()
-    async def view(self, interaction: nextcord.Interaction):
-        """
-        Parent slash command for view. Never called.
-        """
-
-    @view.subcommand(description="Lists all scores for a given category.")
-    async def leaderboard(
-        self,
-        interaction: nextcord.Interaction,
-        group_id: str = nextcord.SlashOption(
-            name="group", description="Group to show leaderboard from.", required=True
-        ),
-        category_id: str = nextcord.SlashOption(
-            name="category", description="Category to show leaderboard.", required=True
-        ),
-    ):
-        """
-        Gathers all users that have a submission in the group/category combo and returns a message with them
-        in ranked order.
-
-        Args:
-            interaction (nextcord.Interaction): Interaction that invoked the command.
-            group_id (str): String representation of Group id to search from. Is SlashOption.
-            category_id (str): String representation of Category id to show leaderboard. Is SlashOption.
-        """
-        str_list: "list[str]" = []
-
-        # get group, category, and all scores sorted correctly.
-        with Session(engine) as session:
-            stmt = select(CategoryGroup).where(CategoryGroup.GroupId == int(group_id))
-            group = session.scalar(stmt)
-
-            stmt = select(Category).where(Category.CategoryId == int(category_id))
-            category = session.scalar(stmt)
-
-            d_f = pd.read_sql_query(
-                sql=session.query(Score).where(Score.CategoryId == category_id).statement, con=engine
-            )
-
-        scores = d_f.sort_values("Score", ascending=category.IsAscending).reset_index()
-
-        # get the longest string
-        longest_str: int = scores.UserName.map(len).max()
-
-        for i, row in scores.iterrows():
-            str_list.append(
-                format_score_string(
-                    row["UserName"], row["Score"], longest_str, category.IsTimeRecord, i + 1, MAX_LINE_LENGTH
-                )
-            )
-
-        message_str: str = f"**{group.GroupName} {category.CategoryName} Leaderboard!**\n```"
-        if len(str_list) == 0:
-            message_str += "No Submissions!"
-        else:
-            for line in str_list:
-                message_str += f"{line}\n"
-
-        message_str += "```"
-
-        await interaction.response.send_message(content=message_str)
-
-    @leaderboard.on_autocomplete("group_id")
-    async def group_autocomplete(self, interaction: nextcord.Interaction, group_id: str):
-        """
-        Autocomplete function for table names.
-
-        Args:
-            interaction (nextcord.Interaction): Interaction that invoked the command.
-            group_id (str): String to be autocompleted with Group name.
-        """
-        await interaction.response.send_autocomplete(autofill_groups(interaction.guild_id, group_id))
-
-    @leaderboard.on_autocomplete("category_id")
-    async def category_autocomplete(self, interaction: nextcord.Interaction, category_id: str, group_id: str):
-        """
-        Autocomplete function for category names.
-
-        Args:
-            interaction (nextcord.Interaction): Interaction that invoked the command.
-            category_id (str): String to be autocompleted with Category name.
-            group_id (str): Group to find Category from.
-        """
-        await interaction.response.send_autocomplete(
-            autofill_categories(interaction.guild_id, int(group_id), category_id)
-        )

cogs/guild_listener/__init__.py

@@ -4,11 +4,11 @@ Defines cog for guild listeners. Contains functions for various guild events.
 
 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 add_preset_configuration
 
 
 class GuildListener(commands.Cog, name="Guild Listener"):
@@ -21,24 +21,12 @@ class GuildListener(commands.Cog, name="Guild Listener"):
     async def on_guild_join(self, guild: nextcord.Guild):
         """Listener for Guild Join. Adds guild to database."""
 
+        new_guild = Guild(GuildId=guild.id)
+
         with Session(engine) as session:
-            stmt = select(Guild).where(Guild.GuildId == guild.id)
-            guild_data = session.scalar(stmt)
-
-            # just in case check if the guild already exists
-            if guild_data is None:
-                new_guild = Guild(GuildId=guild.id, GuildName=guild.name)
             session.add(new_guild)
-            else:
-                guild_data.GuildName = guild.name
-
             session.commit()
 
-        # let imcompiling#2272 know about a new server joining!
-        # staying with fetch due to intents not being set up correctly. Maybe change to get eventually.
-        imcompiling: nextcord.User = await self.bot.fetch_user(206602713511886849)
-        await imcompiling.send(f'Agon has joined server "{guild.name}"!')
-
 
 # This function will be called when this extension is loaded.
 # It is necessary to add these functions to the bot.

cogs/loops/__init__.py

@@ -1,16 +0,0 @@
-"""
-Initializing code for all loops.
-"""
-
-from nextcord.ext import commands
-
-from .bot_presence import BotPresence
-from .guild_data import GuildData
-
-
-# This function will be called when this extension is loaded.
-# It is necessary to add these functions to the bot.
-def setup(bot: commands.Bot):
-    """Adds function to bot"""
-    bot.add_cog(BotPresence(bot))
-    bot.add_cog(GuildData(bot))

cogs/loops/guild_data.py

@@ -1,48 +0,0 @@
-"""
-Contains a loop that updates guild data in the database periodically.
-"""
-
-from nextcord.ext import commands, tasks
-from sqlalchemy import select
-from sqlalchemy.orm import Session
-
-# pylint: disable=import-error
-from utilities.sql_data_classes import Guild, engine
-
-
-class GuildData(commands.Cog, name="Guild Data"):
-    """Class to contain loop."""
-
-    def __init__(self, bot: commands.bot) -> None:
-        self.bot = bot
-
-    @commands.Cog.listener()
-    async def on_ready(self):
-        """Starts the loop when bot is ready."""
-        await self.bot.wait_until_ready()
-        # pylint doesn't recognize that periodic_update_guild_data is subclassed from tasks.loop.
-        await self.periodic_update_guild_data.start()  # pylint: disable=no-member
-
-    @tasks.loop(hours=24)
-    async def periodic_update_guild_data(self):
-        """Loops every day, calls update_guild_data."""
-        self.update_guild_data()
-
-    def update_guild_data(self):
-        """
-        Updates all known guild's data in the database.
-        """
-        with Session(engine) as session:
-            for guild in self.bot.guilds:
-                # update given guild name for guild id
-                stmt = select(Guild).where(Guild.GuildId == guild.id)
-                guild_data = session.scalar(stmt)
-
-                # just in case checking if the guild doesn't exist.
-                if guild_data is None:
-                    new_guild = Guild(GuildId=guild.id, GuildName=guild.name)
-                    session.add(new_guild)
-                else:
-                    guild_data.GuildName = guild.name
-
-                session.commit()

cogs/message_listener/__init__.py

@@ -11,7 +11,7 @@ from sqlalchemy.orm import Session
 
 # pylint: disable=import-error
 from classes.submission import SubmissionState
-from highscores import submission_objects
+from agon import submission_objects
 from utilities.sql_data_classes import Category, Guild, engine
 
 
@@ -45,7 +45,6 @@ class SubmissionListener(commands.Cog, name="Message Listener"):
                 if message.channel.id == submission_channel_id:
                     state = submission.submission_state
                     if state == SubmissionState.SCORE and message.content:
-
                         stmt = select(Category.IsTimeRecord).where(Category.CategoryId == submission.category_id)
 
                         # check with regex if score matches correctly

cogs/presence/__init__.py

@@ -1,5 +1,5 @@
 """
-Functions for controlling the bot's presence. Also contains the loop.
+Functions for controlling the bot's presence.
 """
 
 import random
@@ -46,3 +46,10 @@ class BotPresence(commands.Cog, name="Bot Presence"):
         status += f" | {len(self.bot.guilds)} servers"
 
         await self.bot.change_presence(activity=nextcord.Game(status))
+
+
+# This function will be called when this extension is loaded.
+# It is necessary to add these functions to the bot.
+def setup(bot: commands.Bot):
+    """Adds function to bot"""
+    bot.add_cog(BotPresence(bot))

cogs/submission/submission_views.py

@@ -9,7 +9,7 @@ from sqlalchemy.orm import Session, aliased
 
 # pylint: disable=import-error
 from classes.submission import Submission, SubmissionState
-from highscores import submission_objects
+from agon import submission_objects
 from utilities.sql_data_classes import Category, CategoryGroup, Guild, engine
 
 from .verification_view import VerificationView

docker-compose.yml

@@ -0,0 +1,29 @@
+version: "3"
+services:
+  sqldb:
+    restart: unless-stopped
+    image: mysql:latest
+    container_name: "Highscores-DataBase"
+    volumes:
+      - highscores_data:/var/lib/mysql
+    ports:
+      - 3306:3306
+    environment:
+      - MYSQL_ROOT_PASSWORD=${SQL_PASS}
+      - MYSQL_ROOT_USERNAME=${SQL_USER}
+
+  bot:
+    restart: unless-stopped
+    build: .
+    container_name: "Highscores-Bot"
+    depends_on:
+      - sqldb
+    environment:
+      - DISCORD_TOKEN=${DISCORD_TOKEN}
+      - SQL_DB=${SQL_DB}
+      - SQL_HOST=${SQL_HOST}
+      - SQL_PASS=${SQL_PASS}
+      - SQL_USER=${SQL_USER}
+
+volumes:
+  highscores_data:

highscores_database.sql

@@ -3,7 +3,6 @@ use highscores;
 
 CREATE TABLE Guilds(
    GuildId bigint unsigned not null unique,
-   GuildName varchar(95) not null,
    SubmissionChannel bigint unsigned,
    VerificationChannel bigint unsigned,
    PRIMARY KEY (GuildId)
@@ -18,7 +17,7 @@ CREATE TABLE CategoryGroups(
    PadLength smallint not null DEFAULT 26,
    UsernameLength smallint DEFAULT 12,
    CONSTRAINT UniqueGuildCategoryGroup UNIQUE (GuildId, GroupName),
-   FOREIGN KEY (GuildId) REFERENCES Guilds(GuildId) ON DELETE CASCADE,
+   FOREIGN KEY (GuildId) REFERENCES Guilds(GuildId),
    PRIMARY KEY (GroupId)
 );
 
@@ -31,7 +30,7 @@ CREATE TABLE Categories(
    IsTimeRecord boolean not null DEFAULT false,
    IsValidated boolean not null DEFAULT true,
    CONSTRAINT UniqueCategoryInGroup UNIQUE (GroupId, CategoryName),
-   FOREIGN KEY (GroupId) REFERENCES CategoryGroups(GroupId) ON DELETE CASCADE,
+   FOREIGN KEY (GroupId) REFERENCES CategoryGroups(GroupId),
    PRIMARY Key (CategoryId)
 );
 
@@ -39,6 +38,6 @@ CREATE TABLE Scores(
    UserName varchar(30) not null,
    Score float not null, -- Maybe should have time and int scores?? timestamp type?
    CategoryId int unsigned not null,
-   FOREIGN KEY (CategoryId) REFERENCES Categories(CategoryId) ON DELETE CASCADE,
+   FOREIGN KEY (CategoryId) REFERENCES Categories(CategoryId),
    PRIMARY KEY (CategoryId, UserName)
 );

utilities/utils.py

@@ -40,18 +40,18 @@ def autofill_categories(guild_id: int, group_id: int, category_begin: str) -> "d
         )
         cat_group_alias = aliased(CategoryGroup, subq)
         stmt = select(Category).where(Category.GroupId == cat_group_alias.GroupId)
-        categories_dict: "dict[str, str]" = {cat.CategoryName: str(cat.CategoryId) for cat in session.scalars(stmt)}
+        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:
-        return dict(list(category_begin.items())[:25])
+        return categories_dict
 
     # else find all categories that start with category_begin
     # TODO is it better to have sql handle the starts with or python?
-    categories: "dict[str, str]" = {
+    categories: dict = {
         cat_name: cat_id for cat_name, cat_id in categories_dict.items() if category_begin.lower() in cat_name.lower()
     }
-    return dict(list(categories.items())[:25])
+    return categories
 
 
 def autofill_groups(guild_id: int, group_begin: str) -> "dict[str, str]":
@@ -71,18 +71,18 @@ def autofill_groups(guild_id: int, group_begin: str) -> "dict[str, str]":
         stmt = select(CategoryGroup).where(CategoryGroup.GuildId == guild_id)
 
         # dict has to have key values of same type for discord.
-        group_dict: "dict[str, str]" = {group.GroupName: str(group.GroupId) for group in session.scalars(stmt)}
+        group_dict: dict = {group.GroupName: str(group.GroupId) for group in session.scalars(stmt)}
 
     # if string empty, return all group names
     if not group_begin:
-        return dict(list(group_dict.items())[:25])
+        return group_dict
 
     # else find all groups that start with group_begin
-    groups: "dict[str, str]" = {
+    groups: dict = {
         group_name: group_id for group_name, group_id in group_dict.items() if group_begin.lower() in group_name.lower()
     }
 
-    return dict(list(groups.items())[:25])
+    return groups
 
 
 def autofill_users_in_group_category(guild_id: int, group_id: int, category_id: int, user_begin: str) -> "list[str]":
@@ -130,12 +130,12 @@ def autofill_users_in_group_category(guild_id: int, group_id: int, category_id:
 
     # if string empty, return all users
     if not user_begin:
-        return users_list[:25]
+        return users_list
 
     # else find all users that start with user_begin
-    users: "list[str]" = [user for user in users_list if user_begin.lower() in user.lower()]
+    users = [user for user in users_list if user_begin.lower() in user.lower()]
 
-    return users[:25]
+    return users
 
 
 def autofill_users_in_guild(guild_id: int, user_begin: str) -> "list[str]":
@@ -158,12 +158,12 @@ def autofill_users_in_guild(guild_id: int, user_begin: str) -> "list[str]":
 
     # if string empty, return all users
     if not user_begin:
-        return users_list[:25]
+        return users_list
 
     # else find all users that start with user_begin
-    users: "list[str]" = [user for user in users_list if user_begin.lower() in user.lower()]
+    users = [user for user in users_list if user_begin.lower() in user.lower()]
 
-    return users[:25]
+    return users
 
 
 def format_highscore_message(session: Session, group: CategoryGroup) -> str:
@@ -231,12 +231,20 @@ def format_highscore_message(session: Session, group: CategoryGroup) -> str:
             # add each score to list
             for ind in range(max_cat_size):  # need to subtract to deal with category name string
                 if ind in processed_group.index:
-                    username = processed_group["UserName"][ind]
-                    score = processed_group["Score"][ind]
+                    user_length = group.UsernameLength
+                    username = processed_group["UserName"][ind][:user_length].ljust(user_length, " ")
 
-                    str_list[ind + 1] += format_score_string(
-                        username, score, group.UsernameLength, category.IsTimeRecord, ind + 1, pad_length
-                    )
+                    # get score, pad to correct length
+                    if category.IsTimeRecord:
+                        # MM:SS.ms is 7 characters long
+                        # if there are single digit minutes, add a space for formatting.
+                        score = get_time_str(processed_group["Score"][ind])
+                        if score.find(":") and len(score.split(":", maxsplit=1)[0]) < 2:
+                            score = " " + score
+                    else:
+                        score = str(int(processed_group["Score"][ind])).rjust(7, " ")
+
+                    str_list[ind + 1] += f"{ind + 1}: {username} - {score}".ljust(pad_length, " ")
                 else:
                     # if not enough entries, pad out
                     if ind + 1 <= category.Size:
@@ -254,6 +262,7 @@ def format_highscore_message(session: Session, group: CategoryGroup) -> str:
     # need to use index to allow for modifying the list
     for ind, line in enumerate(str_list):
         if len(line) > MAX_LINE_LENGTH:
+
             split_loc = int(MAX_LINE_LENGTH / pad_length) * pad_length
             new_line = line[split_loc:]
             str_list[ind] = line[:split_loc]
@@ -274,38 +283,6 @@ def format_highscore_message(session: Session, group: CategoryGroup) -> str:
     return ret_string + "```"
 
 
-def format_score_string(
-    username: str, score: float, username_length: int, is_time_record: bool, rank: int, pad_length: int
-) -> str:
-    """
-    Builds the string to show a user's score.
-
-    Args:
-        username (str): username.
-        score (int): score in int form.
-        username_length (float): limit to how long username is allowed to be.
-        is_time_record (bool): if the score represents an number or a time record.
-        rank (int): the user's rank.
-        pad_length (int): limit to how long the string can be.
-
-    Returns:
-        str: string to show user's score.
-    """
-    username = username[:username_length].ljust(username_length, " ")
-
-    # get score, pad to correct length
-    if is_time_record:
-        # MM:SS.ms is 7 characters long
-        # if there are single digit minutes, add a space for formatting.
-        score = get_time_str(score)
-        if score.find(":") and len(score.split(":", maxsplit=1)[0]) < 2:
-            score = " " + score
-    else:
-        score = str(int(score)).rjust(7, " ")
-
-    return f"{rank}: {username} - {score}".ljust(pad_length, " ")
-
-
 def get_time_str(time_in: float) -> str:
     """
     Formats a float value into the desired string format for a timestamp.