Added verify and submission register subcommands. Removed bot argument from Register class.

Create register group and highscore slash subcommand.
Change constructor of score. Create new function to add score value from a string.
2022-08-06 22:21:08 -04:00 · 2022-08-06 20:14:30 -04:00 · 2022-08-06 17:32:17 -04:00 · 2022-08-06 16:55:06 -04:00 · 2022-08-06 16:45:05 -04:00 · 2022-08-06 16:41:50 -04:00
21 changed files with 1574 additions and 517 deletions
@@ -132,6 +132,6 @@ nextcord.log

 # data file for bot
 highscores_data.json
-highscores_message_map.json
 highscores_config.json
-deleted_backups/
+deleted_backups/
+highscores_data/
@@ -0,0 +1,190 @@
+"""File for Category class."""
+
+import json
+
+from classes.score import Score, ScoreTime  # pylint: disable=import-error
+
+
+class Category:
+    """Stores a category's information and relative scores."""
+
+    def __init__(self, name: str) -> None:
+        """
+        Default constructor for Category class. Creates empty category and populates with defaults.
+
+        Args:
+            name (str): Category's name
+        """
+        self._name: str = name
+        self._ascending: bool = False
+        self._time_record: bool = False
+        self._scores_map: dict = {}
+
+    def __str__(self) -> str:
+        """
+        Returns Category class as a string for printing.
+
+        Returns:
+            str: Category class as a string
+        """
+        return self.to_str()
+
+    @classmethod
+    def from_dict(cls, name: str, data: dict):
+        """
+        Creates a Category class from the passed data.
+
+        Args:
+            name (str): Category name
+            data (dict): Rest of Category data in dictionary format
+
+        Returns:
+            Category: Populated Category object
+        """
+        category = cls(name)
+        category.ascending = data["ascending"]
+        category.time_record = data["time_record"]
+        for user, score in data["scores"].items():
+            if category.time_record:
+                score_obj: ScoreTime = ScoreTime(user)
+                score_obj.value = float(score)
+                category.add_score(score_obj)
+            else:
+                score_obj: Score = Score(user)
+                score_obj.value = int(score)
+                category.add_score(score_obj)
+
+        return category
+
+    @property
+    def ascending(self) -> bool:
+        """
+        Getter for is ascending.
+
+        Returns:
+            bool: is ascending
+        """
+        return self._ascending
+
+    @ascending.setter
+    def ascending(self, ascending: bool) -> None:
+        """
+        Setter for is ascending.
+
+        Args:
+            ascending (bool): is ascending
+        """
+        self._ascending = ascending
+
+    @property
+    def name(self) -> str:
+        """
+        Getter for name.
+
+        Returns:
+            str: name
+        """
+        return self._name
+
+    @property
+    def time_record(self) -> bool:
+        """
+        Getter for is time record.
+
+        Returns:
+            bool: is time record
+        """
+        return self._time_record
+
+    @time_record.setter
+    def time_record(self, time_record: bool) -> None:
+        """
+        Setter for is time record.
+
+        Args:
+            time_record (bool): is time record
+        """
+        self._time_record = time_record
+
+    @property
+    def scores(self) -> "list[Score]":
+        """
+        Getter for Scores list.
+
+        Returns:
+            list[Score]: List of Scores in this Category
+        """
+        return self._scores_map.values()
+
+    def add_score(self, score: Score) -> None:
+        """
+        Adds score to dictionary storage map. Sorts dictionary by score value.
+
+        Args:
+            score (Score): Score to be added
+        """
+        if score.user in self._scores_map:
+            self._scores_map[score.user].value = score.value
+        else:
+            self._scores_map[score.user] = score
+
+        self._scores_map = dict(
+            sorted(self._scores_map.items(), key=lambda x: x[1].value, reverse=not self.ascending)
+        )
+
+    def clear(self) -> None:
+        """
+        Clears all Scores tracked in score map.
+        This is a test function and shouldn't really be used.
+        """
+        self._scores_map.clear()
+
+    def get_user_score(self, user: str) -> Score:
+        """
+        Gets a user's score. Returns None if user is not found.
+
+        Args:
+            user (str): Name of score to find
+
+        Returns:
+            Score: User's Score or None
+        """
+        if user in self._scores_map:
+            return self._scores_map[user]
+        return None
+
+    def remove_score(self, score: str) -> None:
+        """
+        Removes a user's score from dictionary storage.
+
+        Args:
+            score (str): user whose score to remove
+        """
+        score = self._scores_map.pop(score)
+        del score
+
+    def to_dict(self) -> dict:
+        """
+        Saves category data as a python dictionary.
+        Does not include category name. It should be the key of above data structure.
+
+        Returns:
+            dict: Category class in dictionary format
+        """
+        data = {}
+        data["ascending"] = self.ascending
+        data["time_record"] = self.time_record
+        data["scores"] = {}
+        for score in self.scores:
+            data["scores"][score.user] = score.value
+
+        return data
+
+    def to_str(self) -> str:
+        """
+        Returns Category object as a string.
+
+        Returns:
+            str: string of json representation of Category
+        """
+        return json.dumps(self.to_dict(), indent=4)
@@ -0,0 +1,211 @@
+"""File for Guild class."""
+
+import json
+
+from classes.table import Table  # pylint: disable=import-error
+
+
+class Guild:
+    """Stores a guild's information."""
+
+    def __init__(self, guild_id: int) -> None:
+        """
+        Default constructor for Guild class. Initializes channel ids as 0 as they won't be
+        registered yet. Sets default username length of 12. Default highscores size to 3.
+
+        Args:
+            guild_id (int): Discord Guild id of new Guild
+        """
+        self._guild_id: int = guild_id
+        self._highscore_channel_id: int = 0
+        self._submission_channel_id: int = 0
+        self._table_map: dict = {}
+        self._username_length: int = 12
+        self._verification_channel_id: int = 0
+
+    def __str__(self) -> str:
+        """
+        Returns Guild class as a string for printing.
+
+        Returns:
+            str: Guild class as a string
+        """
+        return self.to_str()
+
+    @classmethod
+    def from_dict(cls, guild_id: int, data: dict):
+        """
+        Creates a Guild class from the passed data.
+
+        Args:
+            guild_id (int): Guild's id
+            data (dict): Rest of Guild data in dictionary format
+
+        Returns:
+            Guild: Populated Guild object
+        """
+        guild = cls(guild_id)
+        guild.highscore_channel = data["highscore_channel_id"]
+        guild.submission_channel = data["submission_channel_id"]
+        guild.username_length = data["username_length"]
+        guild.verification_channel = data["verification_channel_id"]
+
+        for table_name, table_data in data["tables"].items():
+            table = Table.from_dict(table_name, table_data)
+            guild.add_table(table)
+
+        return guild
+
+    @property
+    def guild_id(self) -> int:
+        """
+        Getter for Guild id
+
+        Returns:
+            int: Guild id
+        """
+        return self._guild_id
+
+    @property
+    def highscore_channel(self) -> int:
+        """
+        Getter for highscore channel id.
+
+        Returns:
+            int: highscore channel id
+        """
+        return self._highscore_channel_id
+
+    @highscore_channel.setter
+    def highscore_channel(self, channel: int) -> None:
+        """
+        Setter for highscore channel id.
+
+        Args:
+            channel (int): highscore channel id
+        """
+        self._highscore_channel_id = channel
+
+    @property
+    def submission_channel(self) -> int:
+        """
+        Getter for submission channel id.
+
+        Returns:
+            int: submission channel id
+        """
+        return self._submission_channel_id
+
+    @submission_channel.setter
+    def submission_channel(self, channel: id) -> None:
+        """
+        Setter fro submission channel id.
+
+        Args:
+            channel (id): submission channel id
+        """
+        self._submission_channel_id = channel
+
+    @property
+    def tables(self) -> "list[Table]":
+        """
+        Getter for Tables list.
+
+        Returns:
+            list[Table]: List of Tables in this Guild
+        """
+        return self._table_map.values()
+
+    @property
+    def username_length(self) -> int:
+        """
+        Getter for username length.
+
+        Returns:
+            int: username length
+        """
+        return self._username_length
+
+    @username_length.setter
+    def username_length(self, length: int) -> None:
+        """
+        Setter for username length.
+
+        Args:
+            length (int): username length
+        """
+        self._username_length = length
+
+    @property
+    def verification_channel(self) -> int:
+        """
+        Getter for verification channel id.
+
+        Returns:
+            int: verification channel id
+        """
+        return self._verification_channel_id
+
+    @verification_channel.setter
+    def verification_channel(self, channel: int) -> None:
+        """
+        Setter for verification channel id
+
+        Args:
+            channel (int): verification channel id
+        """
+        self._verification_channel_id = channel
+
+    def add_table(self, table: Table) -> None:
+        """
+        Adds a Table to table map. Shouldn't exist already.
+
+        Args:
+            table (Table): new Table to add
+        """
+        if table.name not in self._table_map:
+            self._table_map[table.name] = table
+
+    def get_table(self, table_name: str) -> Table:
+        """
+        Getter for specific Table. Returns None if Table is not found.
+
+        Args:
+            table_name (str): Name of Table to find
+
+        Returns:
+            Table: Table corresponding to Name. None if not found.
+        """
+        if table_name in self._table_map:
+            return self._table_map[table_name]
+        return None
+
+    def to_dict(self) -> dict:
+        """
+        Creates python dictionary object from class data.
+        Does not include guild_id in dict, it should be the key of above data structure.
+
+        Returns:
+            dict: Guild class in dictionary format
+        """
+        data: dict = {}
+
+        data["highscore_channel_id"] = self.highscore_channel
+        data["submission_channel_id"] = self.submission_channel
+        data["tables"] = {}
+        data["username_length"] = self.username_length
+        data["verification_channel_id"] = self.verification_channel
+
+        for table in self.tables:
+            data["tables"][table.name] = table.to_dict()
+
+        return data
+
+    def to_str(self) -> str:
+        """
+        Returns Guild object as a string.
+
+        Returns:
+            str: string of json representation of Guild
+        """
+        return json.dumps(self.to_dict(), indent=4)
@@ -0,0 +1,153 @@
+"""Class and functions for storing and retrieving highscores data."""
+
+import os
+import json
+
+from classes.guild import Guild  # pylint: disable=import-error
+from classes.table import Table  # pylint: disable=import-error
+from classes.category import Category  # pylint: disable=import-error
+
+
+HIGHSCORES_BACKUP_DIR = "deleted_backups"
+HIGHSCORES_CONFIG_DIR = "example_config"
+HIGHSCORES_DATA_DIR = "highscores_data"
+
+
+class HighscoresData:
+    """Class for storing and retrieving highscores data."""
+
+    def __init__(self) -> None:
+        """
+        Default constructor for Highscores Data. Opens up known highscores data on creation.
+        """
+        self._guild_map: dict = {}
+
+        # Ensure that data directories exist.
+        if not os.path.exists(HIGHSCORES_BACKUP_DIR):
+            os.mkdir(HIGHSCORES_BACKUP_DIR)
+        if not os.path.exists(HIGHSCORES_DATA_DIR):
+            os.mkdir(HIGHSCORES_DATA_DIR)
+        self.open_highscores_data()
+
+    def __str__(self) -> str:
+        """
+        Returns Highscores class as a string for printing.
+        Returns:
+            str: Highscores class as a string
+        """
+        data: dict = {}
+        for guild_id, guild_obj in self._guild_map.items():
+            data[guild_id] = guild_obj.to_dict()
+        return "Highscores Data\n" + json.dumps(data, indent=4)
+
+    @property
+    def guilds(self) -> "list[Guild]":
+        """
+        Getter for Guilds list.
+
+        Returns:
+            list[Guild]: List of Guilds tracked by Highscores Bot
+        """
+        return self._guild_map.values()
+
+    def add_configuration(self, guild_id: int, config_str: str) -> None:
+        """
+        Adds an example configuration to a Guild. Uses guild id to know which guild and
+        config name to open a file in example_config.
+
+        Args:
+            guild_id (int): Guild id to add config to
+            config_str (str): Config name to add
+        """
+        config = self._open_highscores_config(config_str)
+        guild = self.get_guild(guild_id)
+
+        for table_name, categorys in config["tables"].items():
+            table_obj = Table(table_name)
+            table_obj.size = config["table_size"]
+            for category_name in categorys:
+                category = Category(category_name)
+                category.ascending = config["categories"][category.name]["ascending"]
+                category.time_record = config["categories"][category.name]["is_time_record"]
+                table_obj.add_category(category)
+
+            guild.add_table(table_obj)
+
+    def add_guild(self, guild_id: int) -> None:
+        """
+        Creates a new Guild and adds to Guild map.
+
+        Args:
+            guild_id (int): Guild Id to add
+        """
+        guild: Guild = Guild(guild_id)
+        self._guild_map[guild_id] = guild
+
+    def get_guild(self, guild_id: int) -> Guild:
+        """
+        Getter for Guild object that corresponds with the guild_id.
+
+        Args:
+            guild_id (int): id of Guild to retrieve.
+
+        Returns:
+            Guild: Guild object for guild_id
+        """
+        return self._guild_map[guild_id]
+
+    def remove_guild(self, guild_id: int) -> None:
+        """
+        Removes a guild's data from object. Saves backup.
+
+        Args:
+            guild_id (int): guild id to remove
+        """
+        self._guild_map.pop(guild_id)
+
+        os.rename(
+            f"{HIGHSCORES_DATA_DIR}/{guild_id}.json", f"{HIGHSCORES_BACKUP_DIR}/{guild_id}.json"
+        )
+
+    def _open_highscores_config(self, config: str) -> dict:
+        """
+        Opens the highscores config file and returns in dictionary format.
+        Will be replaced when config class is created.
+
+        Args:
+            config (str): Name of config to load.
+
+        Returns:
+            dict: dict of highscores config
+        """
+        with open(f"{HIGHSCORES_CONFIG_DIR}/{config}.json", encoding="utf-8", mode="r") as file:
+            return json.load(file)
+
+    def open_highscores_data(self):
+        """
+        Opens all saved highscores data in the HIGHSCORES_DATA_DIR dir. Creates a Guild object from
+        each file and adds to guild map.
+        """
+        for data_file in os.listdir(HIGHSCORES_DATA_DIR):
+            guild_id: int = int(data_file.split(".", maxsplit=1)[0])
+            with open(f"{HIGHSCORES_DATA_DIR}/{data_file}", encoding="utf-8", mode="r") as file:
+                guild_obj: Guild = Guild.from_dict(guild_id, json.load(file))
+                self._guild_map[guild_obj.guild_id] = guild_obj
+
+    def save_all_data(self) -> None:
+        """
+        Calls save_guild_data for each guild tracked in guild map.
+        """
+        for guild in self.guilds:
+            self.save_guild_data(guild)
+
+    def save_guild_data(self, guild: Guild) -> None:
+        """
+        Saves a guild to its own json file.
+
+        Args:
+            guild (Guild): Guild to save
+        """
+        with open(
+            f"{HIGHSCORES_DATA_DIR}/{guild.guild_id}.json", encoding="utf-8", mode="w"
+        ) as file:
+            file.write(guild.to_str())  # should use str function
@@ -0,0 +1,144 @@
+"""File for Score classes"""
+
+import time
+
+
+class Score:
+    """Parent class for Scores. Stores common information for a Score."""
+
+    # no user setter, it should never change.
+
+    def __init__(self, user: str) -> None:
+        """
+        Default constructor for Score class.
+
+        Args:
+            user (str): Score's user
+            value (int): Score's value
+        """
+        self._user: str = user
+        self._value: int = -1
+
+    def __str__(self) -> str:
+        """
+        Returns Score class as a string for printing.
+
+        Returns:
+            str: Score class as a string
+        """
+        return self.to_str()
+
+    @property
+    def user(self) -> str:
+        """
+        Getter for score user.
+
+        Returns:
+            str: user
+        """
+        return self._user
+
+    @property
+    def value(self) -> int:
+        """
+        Getter for score value.
+
+        Returns:
+            int: value
+        """
+        return self._value
+
+    @value.setter
+    def value(self, value: int) -> None:
+        """
+        Setter for score value.
+
+        Args:
+            value (int): score value input
+        """
+        self._value = value
+
+    def get_str(self) -> str:
+        """
+        Gets score's value as string.
+
+        Returns:
+            str: Score's value
+        """
+        return str(self._value)
+
+    def set_value_str(self, value: str) -> None:
+        """
+        Setter for score value from string.
+
+        Args:
+            value (str): int as a string
+        """
+        self._value = int(value)
+
+    def to_str(self) -> str:
+        """
+        Returns Score object as a string.
+
+        Returns:
+            str: string of json representation of Score
+        """
+        return f"{self.user}: {self.get_str()}"
+
+
+class ScoreTime(Score):
+    """Class for a time based score. Inherits from Score."""
+
+    def __init__(self, user: str) -> None:  # pylint: disable=super-init-not-called
+        """
+        Default constructor for ScoreTime class.
+
+        Args:
+            user (str): Score's user
+            score (float): Score's value
+        """
+        # store time score as seconds.
+        self._user: str = user
+        self._score: float = -1.0
+
+    @property
+    def value(self) -> float:
+        """
+        Getter for score value.
+
+        Returns:
+            float: value
+        """
+        return self._score
+
+    @value.setter
+    def value(self, value: float) -> None:
+        """
+        Setter for score value.
+
+        Args:
+            value (float): value
+        """
+        self._score = value
+
+    def get_str(self) -> str:
+        """
+        Gets score's value as string. Turns seconds into MM:SS.ms format.
+
+        Returns:
+            str: value in time format.
+        """
+        milliseconds = round((self.value - int(self.value)) * 10)
+        return time.strftime(f"%-M:%S.{milliseconds}", time.gmtime(self.value))
+
+    def set_value_str(self, value: str) -> None:
+        """
+        Setter for score value from a string.
+
+        Args:
+            value (str): string representation of time
+        """
+        if value.find(":"):
+            self._score = int(value.split(":")[0]) * 60 + float(value.split(":")[1])
+        else:
+            self._score = float(value)
@@ -0,0 +1,256 @@
+"""
+Contains classes and enum for tracking data on submissions.
+"""
+
+from enum import Enum
+
+
+from nextcord import Embed
+
+
+class SubmissionState(Enum):
+    """
+    Enum for which state a submission is in
+    """
+
+    CATEGORY = 1
+    SCORE = 2
+    PROOF = 3
+    NAME = 4
+    SUBMIT = 5
+    VERIFY = 6
+
+
+class Submission:
+    """
+    Class for an individual submission. Contains submission information such as
+    guild id, message id, table, category, username, score and submission state.
+    """
+
+    def __init__(self, guild_id: int, table: str, username: str) -> None:
+        """
+        Default constructor for Submission. Just need to know guild_id, table, and username.
+        Score and category are defaulted at empty, message id is 0, and submission state
+        is SubmissionState.CATEGORY.
+        """
+        self._category: str = ""
+        self._guild_id: int = guild_id
+        self._message_id: int = 0
+        self._score: str = ""
+        self._submission_state: SubmissionState = SubmissionState.CATEGORY
+        self._table: str = table
+        self._username: str = username
+
+    @property
+    def category(self) -> str:
+        """
+        Getter for Submission's Category name.
+
+        Returns:
+            str: Category name.
+        """
+        return self._category
+
+    @category.setter
+    def category(self, category: str) -> None:
+        """
+        Setter for Submission's Category name.
+
+        Args:
+            category (str): Category name
+        """
+        self._category = category
+
+    @property
+    def guild_id(self) -> int:
+        """
+        Getter for guild id Submission is happening in. Will not change.
+
+        Returns:
+            int: guild id
+        """
+        return self._guild_id
+
+    @property
+    def message_id(self) -> int:
+        """
+        Getter for message id that Submission has a view on.
+
+        Returns:
+            int: message id
+        """
+        return self._message_id
+
+    @message_id.setter
+    def message_id(self, m_id: int) -> None:
+        """
+        Setter for message id that Submission has a view on.
+
+        Args:
+            m_id (int): message id
+        """
+        self._message_id = m_id
+
+    @property
+    def score(self) -> str:
+        """
+        Getter for score.
+
+        Returns:
+            str: score
+        """
+        return self._score
+
+    @score.setter
+    def score(self, score: str) -> None:
+        """
+        Setter for score.
+
+        Args:
+            score (str): score
+        """
+        self._score = score
+
+    @property
+    def submission_state(self) -> SubmissionState:
+        """
+        Getter for state Submission is in.
+
+        Returns:
+            SubmissionState: State the Submission is in
+        """
+        return self._submission_state
+
+    @submission_state.setter
+    def submission_state(self, state: SubmissionState) -> None:
+        """
+        Setter for state Submission is in.
+
+        Args:
+            state (SubmissionState): State to change to
+        """
+        self._submission_state = state
+
+    @property
+    def table(self) -> str:
+        """
+        Getter for table Submission is for.
+
+        Returns:
+            str: table name
+        """
+        return self._table
+
+    @table.setter
+    def table(self, table: str) -> None:
+        """
+        Getter for table Submission is for.
+
+        Args:
+            table (str): table name
+        """
+        self._table = table
+
+    @property
+    def username(self) -> str:
+        """
+        Getter for Submission owner's username.
+
+        Returns:
+            str: Submission owner's username
+        """
+        return self._username
+
+    @username.setter
+    def username(self, username: str) -> None:
+        """
+        Setter for Submission owner's username.
+
+        Args:
+            username (str): Submission owner's username
+        """
+        self._username = username
+
+    def get_embed(self) -> Embed:
+        """Creates an embed based off of the submission state and fields filled out."""
+        state: SubmissionState = self.submission_state
+
+        if state is SubmissionState.CATEGORY:
+            description = "Step 1: Choose your category!"
+        elif state is SubmissionState.SCORE:
+            description = "Step 2: Input your score!"
+        elif state is SubmissionState.PROOF:
+            description = "Step 3: Submit your proof!"
+        elif state is SubmissionState.NAME:
+            description = (
+                "Step 4 (Optional): Change name on submission! (proceed to next if skipping)"
+            )
+        elif state is SubmissionState.SUBMIT:
+            description = "Step 5: Submit if everything looks correct!"
+        elif state is SubmissionState.VERIFY:
+            description = "Review fields and accept."
+
+        embed = Embed(title="Highscores Submission", description=description)
+        embed.add_field(name="User Name", value=self.username, inline=False)
+        embed.add_field(name="Table", value=self.table, inline=False)
+        if self.category:
+            embed.add_field(name="Category", value=self.category, inline=False)
+        if self.score:
+            embed.add_field(name="Score", value=self.score, inline=False)
+        return embed
+
+
+class SubmissionMap:
+    """
+    Tracks all active submission.
+    """
+
+    def __init__(self) -> None:
+        """
+        Default constructor for SubmissionMap. Created empty map.
+        """
+        self._submission_map: dict = {}
+
+    def add_submission(self, user_id: int, submission: Submission) -> None:
+        """
+        Adds new submission to submission map. User id is used as a key, a user should only
+        have one submission at a time.
+
+        Args:
+            user_id (int): User id of submitter. Unique, used as key.
+            submission (Submission): Submission object
+        """
+        self._submission_map[user_id] = submission
+
+    def get_user_submission(self, user_id: int) -> Submission:
+        """
+        Getter for a user's Submission.
+
+        Args:
+            user_id (int): user id
+
+        Returns:
+            Submission: user's submission
+        """
+        return self._submission_map[user_id]
+
+    def has_user(self, user_id: int) -> bool:
+        """
+        Tells if user has an active submission in submission map.
+
+        Args:
+            user_id (int): user id
+
+        Returns:
+            bool: bool indicating if user id is in submission map
+        """
+        return user_id in self._submission_map
+
+    def remove_user_submission(self, user_id: int) -> None:
+        """
+        Removes a user's Submission. Use when Submission is complete.
+
+        Args:
+            user_id (int): user id to identify user's Submission
+        """
+        self._submission_map.pop(user_id)
@@ -0,0 +1,164 @@
+"""File for Table class."""
+
+import json
+
+from classes.category import Category  # pylint: disable=import-error
+
+
+class Table:
+    """Stores a table's information a list of categories."""
+
+    def __init__(self, name: str) -> None:
+        """
+        Default constructor for Table class.
+        Creates object and fills out class variables with defaults.
+
+        Args:
+            name (str): Table's name
+        """
+        self._name: str = name
+        self._message_id: int = 0
+        self._categories_map: dict = {}
+        self._size = 3
+
+    def __str__(self) -> str:
+        """
+        Returns Table class as a string for printing.
+
+        Returns:
+            str: Table class as a string
+        """
+        return self.to_str()
+
+    @classmethod
+    def from_dict(cls, table_name: str, data: dict):
+        """
+        Creates a Table class from the passed data.
+
+        Args:
+            table_name (str): Table name
+            data (dict): Rest of Table data in dictionary format
+
+        Returns:
+            Table: Populated Table object
+        """
+        table = cls(table_name)
+
+        table.message_id = data["message_id"]
+        table.size = data["table_size"]
+
+        for cat_name, cat in data["categories"].items():
+            category = Category.from_dict(cat_name, cat)
+            table.add_category(category)
+
+        return table
+
+    @property
+    def categories(self) -> "list[Category]":
+        """
+        Getter for Categories list.
+
+        Returns:
+            list[Category]: List of Categories in this Table
+        """
+        return self._categories_map.values()
+
+    @property
+    def message_id(self) -> int:
+        """
+        Getter for message id
+
+        Returns:
+            int: message id
+        """
+        return self._message_id
+
+    @message_id.setter
+    def message_id(self, m_id: int) -> None:
+        """
+        Setter for message id.
+
+        Args:
+            m_id (int): message id
+        """
+        self._message_id = m_id
+
+    @property
+    def name(self) -> str:
+        """
+        Getter for name.
+
+        Returns:
+            str: name
+        """
+        return self._name
+
+    @property
+    def size(self) -> int:
+        """
+        Getter for size of table.
+
+        Returns:
+            int: Size of table
+        """
+        return self._size
+
+    @size.setter
+    def size(self, size: int) -> None:
+        """
+        Setter for size of table.
+
+        Args:
+            size (int): New size of table
+        """
+        self._size = size
+
+    def add_category(self, category: Category) -> None:
+        """
+        Adds a Category to categories map. Shouldn't exist already.
+
+        Args:
+            category (Category): New Category to add
+        """
+        if category.name not in self._categories_map:
+            self._categories_map[category.name] = category
+
+    def get_category(self, category_name: str) -> Category:
+        """
+        Getter for specific category. Returns None if not found.
+
+        Args:
+            category_name (str): name of category to return
+
+        Returns:
+            Category: Category corresponding to name. None if not found.
+        """
+        if category_name in self._categories_map:
+            return self._categories_map[category_name]
+        return None
+
+    def to_dict(self) -> dict:
+        """
+        Saves Table as a python dictionary.
+        Does not include table name. It should be the key of above data structure.
+
+        Returns:
+            dict: Table class in dictionary format
+        """
+        data = {}
+        data["message_id"] = self.message_id
+        data["table_size"] = self.size
+        data["categories"] = {}
+        for category in self.categories:
+            data["categories"][category.name] = category.to_dict()
+
+        return data
+
+    def to_str(self) -> str:
+        """
+        Returns Table object as a string.
+
+        Returns:
+            str: string of json representation of Table
+        """
+        return json.dumps(self.to_dict(), indent=4)
@@ -0,0 +1,42 @@
+"""
+Bot command for deleting the guild's scores.
+"""
+
+from nextcord import Embed
+from nextcord.ext import commands
+
+from highscores import highscores_data  # pylint: disable=import-error
+
+
+class DeleteScores(commands.Cog, name="Delete Scores"):
+    """
+    Warning: This command only works for developers.
+    Deletes this guild's scores.
+    """
+
+    def __init__(self, bot: commands.Bot):
+        self.bot = bot
+
+    @commands.command(name="delete-scores")
+    @commands.has_permissions(administrator=True)
+    async def delete_scores(self, ctx: commands.Context):
+        """A command which deletes all scores for this guild.
+        Usage:
+        ```
+        ?delete_scores
+        ```
+        """
+        # only allow AlwaysCompiling to use.
+        # If you are a developer and want to use command, can add name to list
+        if ctx.author.id == 206602713511886849:
+            for table in highscores_data.get_guild(ctx.guild.id).tables:
+                for category in table.categories:
+                    category.clear()
+            highscores_data.save_guild_data(highscores_data.get_guild(ctx.guild.id))
+
+
+# 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(DeleteScores(bot))
@@ -2,15 +2,10 @@
 Defines cog for guild listeners. Contains functions for various guild events.
 """

-import os
-import json
-
 from nextcord.ext import commands
 import nextcord

 from highscores import highscores_data  # pylint: disable=import-error
-from utilities.data_storage import create_highscore_skeleton  # pylint: disable=import-error
-from utilities.data_storage import save_highscores_data  # pylint: disable=import-error


 class GuildListener(commands.Cog, name="Guild Listener"):
@@ -22,9 +17,10 @@ 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."""
-        # turning guild id into string because json doesn't support ints as object keys.
-        highscores_data[str(guild.id)] = create_highscore_skeleton()
-        save_highscores_data(highscores_data)
+        highscores_data.add_guild(guild.id)
+        # This add config will be removed eventually. Config adding will have to be controlled by commands.
+        highscores_data.add_configuration(guild.id, "runescape")
+        highscores_data.save_guild_data(highscores_data.get_guild(guild.id))

        welcome_message: str = "Hello, I keep track of Highscores for you!"
        welcome_message += " Currently only supporting RuneScape boss highscores,"
@@ -37,14 +33,7 @@ class GuildListener(commands.Cog, name="Guild Listener"):
    async def on_guild_remove(self, guild: nextcord.Guild):
        """Listener for Guild Remove. Removes data from highscores_data."""
        print(f"Removing data for guild {guild.name} (id {guild.id}).")
-        old_data = highscores_data.pop(str(guild.id))
-        save_highscores_data(highscores_data)
-
-        if not os.path.exists("deleted_backups"):
-            os.mkdir("deleted_backups")
-
-        with open(f"deleted_backups/{guild.name}_backup.json", encoding="utf-8", mode="w") as file:
-            file.write(json.dumps(old_data, indent=4))
+        highscores_data.remove_guild(guild.id)


 # This function will be called when this extension is loaded.
@@ -2,16 +2,15 @@
 Defines cog for on message listener.
 """

+from datetime import date
+import random
 import re

 from nextcord.ext import commands
 import nextcord

-from cogs.submission.submission_views import SubmissionState  # pylint: disable=import-error
-from cogs.submission.submission_views import get_submission_embed  # pylint: disable=import-error
-from highscores import highscores_config  # pylint: disable=import-error
-from highscores import highscores_data  # pylint: disable=import-error
-from highscores import submission_objects  # pylint: disable=import-error
+from classes.submission import SubmissionState  # pylint: disable=import-error
+from highscores import highscores_data, submission_objects  # pylint: disable=import-error


 class SubmissionListener(commands.Cog, name="Message Listener"):
@@ -23,36 +22,51 @@ class SubmissionListener(commands.Cog, name="Message Listener"):
    @commands.Cog.listener()
    async def on_message(self, message: nextcord.Message):
        """Listener for message creation. Adds score and attachments to submission."""
+        # don't want to process any messages from bot.
+        if message.author.id == self.bot.user.id:
+            return
+
        guild_id = message.guild.id
-        guild_data = highscores_data[str(guild_id)]
-        if message.author.id in submission_objects:
-            message_id = submission_objects[message.author.id]["message_id"]
+
+        # troll addition for friends birthday
+        if guild_id == 239758371358638080 and date.today() == date(2022, 7, 31):
+            # 5% chance to send the message
+            chance = random.randint(1, 20)
+            if chance == 1:
+                await message.channel.send("Happy Birthday Chris <@642330132958281750>")
+
+        if submission_objects.has_user(message.author.id):
+            submission = submission_objects.get_user_submission(message.author.id)
+            message_id = submission.message_id
+            submission_channel_id = highscores_data.get_guild(guild_id).submission_channel
            submission_message: nextcord.Message = (
                await self.bot.get_guild(guild_id)
-                .get_channel(guild_data["submission_channel_id"])
+                .get_channel(submission_channel_id)
                .fetch_message(message_id)
            )

            # need check if correct user and correct channel
-            if message.channel.id == guild_data["submission_channel_id"]:
-                state = submission_objects[message.author.id]["submission_state"]
+            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 = highscores_config["categories"][
-                        submission_objects[message.author.id]["category"]
-                    ]["is_time_record"]
+                    is_time_record = (
+                        highscores_data.get_guild(guild_id)
+                        .get_table(submission.table)
+                        .get_category(submission.category)
+                        .time_record
+                    )

                    time_regex = re.search(
-                        "([0-9]{2}:)?[0-9]{2}(\.[0-9])?",  # pylint: disable=anomalous-backslash-in-string
-                        message.content,
+                        "^([0-9]{1,2}:[0-9]|[0-9])?[0-9](\\.[0-9])?$", message.content
                    )
-                    int_regex = re.search("[0-9]+", message.content)
+                    int_regex = re.search("^[0-9]+$", message.content)
                    if time_regex is None and is_time_record:
                        embed = submission_message.embeds[0]
                        embed.add_field(
                            name="Error",
-                            value="Time record must follow format MM:SS.ms or SS.ms or SS.",
+                            value="Time record must follow format MM:SS.ms, SS.ms, or SS.",
                        )
                    elif int_regex is None and not is_time_record:
                        embed = submission_message.embeds[0]
@@ -61,15 +75,20 @@ class SubmissionListener(commands.Cog, name="Message Listener"):
                        score = message.content
                        if is_time_record:
                            # standardize time score format.
-                            # add colon if its not there
-                            if score.find(":") == -1:
-                                score = "00:" + score
-                            # add a 0 if there isn't 2 digits before a colon
-                            elif len(score.split(":", maxsplit=1)[0]) < 2:
-                                score = "0" + score
-                        submission_objects[message.author.id]["score"] = score
-                        embed = get_submission_embed(message.author.id)
-
+                            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
+                        embed = submission.get_embed()
                    await submission_message.edit(
                        embed=embed,
                    )
@@ -78,10 +97,10 @@ class SubmissionListener(commands.Cog, name="Message Listener"):
                        files=[await attch.to_file() for attch in message.attachments],
                    )
                elif state == SubmissionState.NAME and message.content:
-                    submission_objects[message.author.id]["username"] = message.content[
-                        : guild_data["username_length"]
+                    submission.username = message.content[
+                        : highscores_data.get_guild(guild_id).username_length
                    ]
-                    embed = get_submission_embed(message.author.id)
+                    embed = submission.get_embed()
                    await submission_message.edit(
                        embed=embed,
                    )
@@ -6,9 +6,7 @@ from nextcord.ext import commands
 import nextcord

 from cogs.submission.submission_views import SubmissionCreateButton  # pylint: disable=import-error
-from highscores import highscores_config  # pylint: disable=import-error
 from highscores import highscores_data  # pylint: disable=import-error
-from utilities.data_storage import save_highscores_data  # pylint: disable=import-error
 from utilities.utils import send_highscore_message  # pylint: disable=import-error


@@ -29,23 +27,27 @@ class PostHighscores(commands.Cog, name="Post Highscores"):
        ?post-scores
        ```
        """
-        guild_data = highscores_data[str(ctx.guild.id)]
-        highscore_channel_id = guild_data["highscore_channel_id"]
-        print(f"Printing out highscores information in channel {highscore_channel_id}")
-        channel = ctx.guild.get_channel(highscore_channel_id)
+        guild = highscores_data.get_guild(ctx.guild.id)
+        print(f"Printing out highscores information in channel {guild.highscore_channel}")
+        channel = ctx.guild.get_channel(guild.highscore_channel)

-        error_response = 'Registered Highscores channel does not exist or was never registered. \n\
-                Register with "?register" command.'
+        error_response = "Registered Highscores channel does not exist or was never registered. "
+        error_response += 'Register with "?register" command.'
        assert channel is not None, await ctx.send(error_response)

-        for boss, categories in highscores_config[  # pylint: disable=unused-variable
-            "tables"
-        ].items():
-            message: nextcord.Message = await send_highscore_message(channel, boss, guild_data)
+        if len(highscores_data.get_guild(ctx.guild.id).tables) < 1:
+            await channel.send(
+                "No tables have been created for this guild. Please create some tables."
+            )
+            return
+
+        for table in highscores_data.get_guild(ctx.guild.id).tables:
+            message: nextcord.Message = await send_highscore_message(channel, guild, table)
            await message.edit(view=SubmissionCreateButton(self.bot))

-        # Saving in case new message was sent.
-        save_highscores_data(highscores_data)
+        # have to save data here in case message id was changed. rather save here after all
+        # messages have been sent.
+        highscores_data.save_guild_data(guild)


 # This function will be called when this extension is loaded.
@@ -0,0 +1,53 @@
+"""
+Functions for controlling the bot's presence.
+"""
+
+import random
+
+from nextcord.ext import commands
+from nextcord.ext import tasks
+import nextcord
+
+
+class BotPresence(commands.Cog, name="Bot Presence"):
+    """Class for bot presence functions."""
+
+    def __init__(self, bot: commands.Bot):
+        self.bot = bot
+
+    @commands.Cog.listener()
+    async def on_guild_join(self, guild: nextcord.Guild):  # pylint: disable=unused-argument
+        """Listener for Guild Join. Updated presence on guild join."""
+        await self.change_presence()
+
+    @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_change_presense is subclassed from tasks.loop.
+        self.periodic_change_presence.start()  # pylint: disable=no-member
+
+    @tasks.loop(minutes=2)
+    async def periodic_change_presence(self):
+        """Loops every 2 minutes and changes presence."""
+        await self.change_presence()
+
+    async def change_presence(self):
+        """Randomly chooses a presence and updates bot's presence."""
+        statuses = [
+            f"?help | {len(self.bot.guilds)} servers",
+            f"Vuln Pls. | {len(self.bot.guilds)} servers",
+            f"All your base are belong to us. | {len(self.bot.guilds)} servers",
+            f"Double plus good. | {len(self.bot.guilds)} servers",
+        ]
+
+        status = random.choice(statuses)
+
+        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))
@@ -2,67 +2,119 @@
 Bot command for registering various channels to the bot.
 """

-from nextcord import Embed
+from typing import Optional
+
+from nextcord import Embed, Interaction, Permissions, SlashOption
+import nextcord
 from nextcord.ext import commands

 from highscores import highscores_data  # pylint: disable=import-error
-from utilities.data_storage import save_highscores_data  # pylint: disable=import-error


-class RegisterVerificationChannel(commands.Cog, name="Register"):
-    """Bot command for registering various channels to the bot."""
+class Register(commands.Cog, name="Register"):
+    """
+    Class holds various register commands.

-    def __init__(self, bot: commands.Bot):
-        self.bot = bot
+    Args:
+        commands.Cog: Parent class
+        name (str, optional): Name of Cog. Defaults to "Register".
+    """

-    @commands.command(name="register")
-    @commands.has_permissions(administrator=True)
-    async def register_highscores(self, ctx: commands.Context, registration_type: str):
-        """A command which registers current channel as for various uses.
-        Usage:
-        ```
-        ?register verify (Use in channel you want to verify submissions in.)
-        ?register highscore (Use in channel you want to show highscore messages in.)
-        ?register submission (Use in channel you want submission messages to be send it.)
-        ?register help (Shows help message.)
-        ```
+    def __init__(self) -> None:
+        """
+        Default constructor for Register class. Does nothing.
        """
-        # respond to the message
-        channel_id = ctx.channel.id
-        guild_data = highscores_data[str(ctx.guild.id)]

-        if registration_type == "verify":
-            await ctx.send(f"Registered <#{channel_id}> as channel to post verifications in.")
-            guild_data["verification_channel_id"] = channel_id
-        elif registration_type == "highscore":
-            await ctx.send(f"Registered <#{channel_id}> as channel to post highscores in.")
-            guild_data["highscore_channel_id"] = channel_id
-        elif registration_type == "submission":
-            await ctx.send(f"Registered <#{channel_id}> as channel to post submissions in.")
-            guild_data["submission_channel_id"] = channel_id
-        else:
-            embed = Embed(
-                title="Register command help", description="How to use the register command."
-            )
-            embed.add_field(
-                name="?register verify", value="Use in channel you want to verify submissions in."
-            )
-            embed.add_field(
-                name="?register highscore",
-                value="Use in channel you want to show highscore messages in.",
-            )
-            embed.add_field(
-                name="?register submission",
-                value="Use in channel you want submission messages to be send it.",
-            )
-            embed.add_field(name="?register help", value="Use to show this message.")
-            await ctx.reply(embed=embed)
+    @nextcord.slash_command(default_member_permissions=Permissions(administrator=True))
+    async def register(self):
+        """
+        Parent slash command, never called.
+        """

-        save_highscores_data(highscores_data)
+    @register.subcommand(description="Registers the channel for perminent highscores messages.")
+    async def highscore(
+        self,
+        interaction: nextcord.Interaction,
+        channel: nextcord.abc.GuildChannel = SlashOption(
+            description="Channel to register",
+            required=False,
+            channel_types=[nextcord.ChannelType.text],
+            default=None,
+        ),
+    ) -> None:
+        """
+        Command function to register the highscore printing channel.
+
+        Args:
+            interaction (nextcord.Interaction): Interaction that invoked the 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
+        guild = highscores_data.get_guild(interaction.guild_id)
+        await interaction.send(f"Registered <#{channel_id}>.", ephemeral=True)
+        guild.highscore_channel = channel_id
+        highscores_data.save_guild_data(guild)
+
+    @register.subcommand(description="Registers the channel for submission messages.")
+    async def submission(
+        self,
+        interaction: nextcord.Interaction,
+        channel: nextcord.abc.GuildChannel = 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 (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
+        guild = highscores_data.get_guild(interaction.guild_id)
+        await interaction.send(f"Registered <#{channel_id}>.", ephemeral=True)
+        guild.submission_channel = channel_id
+        highscores_data.save_guild_data(guild)
+
+    @register.subcommand(description="Registers the channel for verification messages.")
+    async def verify(
+        self,
+        interaction: nextcord.Interaction,
+        channel: nextcord.abc.GuildChannel = 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 (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
+        guild = highscores_data.get_guild(interaction.guild_id)
+        await interaction.send(f"Registered <#{channel_id}>.", ephemeral=True)
+        guild.verification_channel = channel_id
+        highscores_data.save_guild_data(guild)


 # 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):
+def setup(bot: commands.Bot) -> None:
    """Adds function to bot"""
-    bot.add_cog(RegisterVerificationChannel(bot))
+    bot.add_cog(Register())
@@ -1,53 +0,0 @@
-"""
-Bot command to submit a score
-"""
-
-from nextcord.ext import commands
-
-from highscores import highscores_data  # pylint: disable=import-error
-from .verification_view import VerificationView
-
-
-class Score(commands.Cog, name="Score"):
-    """Submits a score."""
-
-    def __init__(self, bot: commands.Bot):
-        self.bot = bot
-
-    @commands.Cog.listener()
-    async def on_ready(self):
-        """Called when the cog is loaded"""
-        self.bot.add_view(VerificationView())
-
-    @commands.command(name="score")
-    async def score(self, ctx: commands.Context, boss_name: str, category: str, score: str):
-        """A command which calls a function to submit the score to highscores.
-        Gathers required information from command and passes on.
-        Usage:
-        ```
-        ?score "Boss Name" "Category" "score"
-        This command still works if you prefer to use it over the ui.
-        ```
-        """
-        guild_data = highscores_data[str(ctx.guild.id)]
-        verification_channel_id = guild_data["verification_channel_id"]
-        channel = ctx.guild.get_channel(verification_channel_id)
-
-        error_response = "Registered Verification channel does not exist or was never registered."
-        error_response += "Contact server admins."
-        assert channel is not None, await ctx.send(error_response)
-
-        verification_string = f"{ctx.author.display_name}:{boss_name}:{category}:{score}"
-
-        await channel.send(
-            content=verification_string,
-            files=[await attch.to_file() for attch in ctx.message.attachments],
-            view=VerificationView(),
-        )
-
-
-# This function will be called when this extension is loaded.
-# It is necessary to add these functions to the bot.
-def setup(bot: commands.Bot):
-    """Adds function to bot"""
-    bot.add_cog(Score(bot))
@@ -1,40 +0,0 @@
-"""View for verification buttons"""
-
-import nextcord
-from utilities.utils import submit_score  # pylint: disable=import-error
-
-
-class VerificationView(nextcord.ui.View):
-    """Defines views for verifying score submissions"""
-
-    def __init__(self):
-        super().__init__(timeout=None)
-
-    @nextcord.ui.button(
-        label="Approve", style=nextcord.ButtonStyle.green, custom_id="approve-score-command"
-    )
-    async def approve_button(
-        self, button: nextcord.ui.Button, interaction: nextcord.Interaction
-    ):  # pylint: disable=unused-argument
-        """Button for approving score submission."""
-        content = interaction.message.content.split(":")
-        user = content[0]
-        boss_name = content[1]
-        category = content[2]
-        score = content[3]
-
-        await submit_score(interaction, user, boss_name, category, score)
-        await interaction.message.delete()
-        await interaction.channel.send(
-            f"Approved: {boss_name} {category} {user} {score}",
-            files=[await attch.to_file() for attch in interaction.message.attachments],
-        )
-
-    @nextcord.ui.button(
-        label="Deny", style=nextcord.ButtonStyle.red, custom_id="deny-score-command"
-    )
-    async def deny_button(
-        self, button: nextcord.ui.Button, interaction: nextcord.Interaction
-    ):  # pylint: disable=unused-argument
-        """Button for denying score submission."""
-        await interaction.message.delete()
@@ -1,64 +1,25 @@
 """Views used for submission process."""

 from typing import Optional
-from enum import Enum

 import nextcord
-from nextcord import Embed
 from nextcord.ext import commands

-from highscores import highscores_config  # pylint: disable=import-error
-from highscores import highscores_data  # pylint: disable=import-error
-from highscores import highscores_message_map  # pylint: disable=import-error
-from highscores import submission_objects  # pylint: disable=import-error
+from classes.submission import Submission, SubmissionState  # pylint: disable=import-error
+from highscores import (  # pylint: disable=import-error
+    highscores_data,
+    highscores_message_map,
+    submission_objects,
+)
 from .verification_view import VerificationView


-class SubmissionState(Enum):
-    """Enum for which state a submission is in"""
-
-    CATEGORY = 1
-    SCORE = 2
-    PROOF = 3
-    NAME = 4
-    SUBMIT = 5
-    VERIFY = 6
-
-
-def get_submission_embed(userid: int) -> nextcord.Embed:
-    """Creates an embed based off of the submission state and fields filled out."""
-    usersubmission: dict = submission_objects[userid]
-    state: SubmissionState = usersubmission["submission_state"]
-
-    if state is SubmissionState.CATEGORY:
-        description = "Step 1: Choose your category!"
-    elif state is SubmissionState.SCORE:
-        description = "Step 2: Input your score!"
-    elif state is SubmissionState.PROOF:
-        description = "Step 3: Submit your proof!"
-    elif state is SubmissionState.NAME:
-        description = "Step 4 (Optional): Change name on submission! (proceed to next if skipping)"
-    elif state is SubmissionState.SUBMIT:
-        description = "Step 5: Submit if everything looks correct!"
-    elif state is SubmissionState.VERIFY:
-        description = "Review fields and accept."
-
-    embed = Embed(title="Highscores Submission", description=description)
-    embed.add_field(name="User Name", value=usersubmission["username"], inline=False)
-    embed.add_field(name="Boss", value=usersubmission["boss_name"], inline=False)
-    if usersubmission["category"]:
-        embed.add_field(name="Category", value=usersubmission["category"], inline=False)
-    if usersubmission["score"]:
-        embed.add_field(name="Score", value=usersubmission["score"], inline=False)
-    return embed
-
-
-def category_select_options(boss_name: str) -> "list[nextcord.SelectOption]":
+def category_select_options(guild_id: int, boss_name: str) -> "list[nextcord.SelectOption]":
    """Returns list of categories for a given boss."""
    options: "list[nextcord.SelectOption]" = []
-    category_list = highscores_config["tables"][boss_name]
+    category_list = highscores_data.get_guild(guild_id).get_table(boss_name).categories
    for category in category_list:
-        options.append(nextcord.SelectOption(label=category))
+        options.append(nextcord.SelectOption(label=category.name))

    return options

@@ -80,8 +41,9 @@ class SubmissionDropdown(nextcord.ui.Select):
        self._bot = bot

    async def callback(self, interaction: nextcord.Interaction):
-        submission_objects[interaction.user.id]["category"] = self.values[0]
-        embed = get_submission_embed(interaction.user.id)
+        submission = submission_objects.get_user_submission(interaction.user.id)
+        submission.category = self.values[0]
+        embed = submission.get_embed()
        await interaction.message.edit(
            embed=embed,
        )
@@ -95,10 +57,11 @@ class BackButton(nextcord.ui.Button):
        self._bot = bot

    async def callback(self, interaction: nextcord.Interaction):
-        state: SubmissionState = submission_objects[interaction.user.id]["submission_state"]
+        submission = submission_objects.get_user_submission(interaction.user.id)
+        state: SubmissionState = submission.submission_state
        state = SubmissionState(state.value - 1)
-        submission_objects[interaction.user.id]["submission_state"] = state
-        embed = get_submission_embed(interaction.user.id)
+        submission.submission_state = state
+        embed = submission.get_embed()
        await interaction.edit(embed=embed, view=SubmissionView(self._bot, interaction.user.id))


@@ -109,7 +72,7 @@ class CancelButton(nextcord.ui.Button):
        super().__init__(label="Cancel", style=nextcord.ButtonStyle.red, custom_id="cancel")

    async def callback(self, interaction: nextcord.Interaction):
-        submission_objects.pop(interaction.user.id)
+        submission_objects.remove_user_submission(interaction.user.id)
        await interaction.message.delete()


@@ -122,22 +85,18 @@ class NextButton(nextcord.ui.Button):

    async def callback(self, interaction: nextcord.Interaction):
        # check if fields have been filled out for each state
-        state: SubmissionState = submission_objects[interaction.user.id]["submission_state"]
-        if (
-            state == SubmissionState.CATEGORY
-            and not submission_objects[interaction.user.id]["category"]
-        ):
+        submission = submission_objects.get_user_submission(interaction.user.id)
+        state: SubmissionState = submission.submission_state
+        if state == SubmissionState.CATEGORY and not submission.category:
            await interaction.send("Please choose a category.", ephemeral=True)
-        elif (
-            state == SubmissionState.SCORE and not submission_objects[interaction.user.id]["score"]
-        ):
+        elif state == SubmissionState.SCORE and not submission.score:
            await interaction.send("Please send a score.", ephemeral=True)
        elif state == SubmissionState.PROOF and not len(interaction.message.attachments) > 0:
            await interaction.send("Please attach picture for proof.", ephemeral=True)
        else:
            state = SubmissionState(state.value + 1)
-            submission_objects[interaction.user.id]["submission_state"] = state
-            embed = get_submission_embed(interaction.user.id)
+            submission.submission_state = state
+            embed = submission.get_embed()
            await interaction.edit(embed=embed, view=SubmissionView(self._bot, interaction.user.id))


@@ -149,18 +108,19 @@ class SubmitButton(nextcord.ui.Button):
        self._bot = bot

    async def callback(self, interaction: nextcord.Interaction):
-        verification_channel_id = highscores_data[str(interaction.guild.id)][
-            "verification_channel_id"
-        ]
+        verification_channel_id = highscores_data.get_guild(
+            interaction.guild_id
+        ).verification_channel
        channel = interaction.guild.get_channel(verification_channel_id)
+        submission = submission_objects.get_user_submission(interaction.user.id)

        error_response = "Registered Verification channel does not exist or was never registered. \
                Contact server admins."
        assert channel is not None, await channel.send(error_response)

-        submission_objects[interaction.user.id]["submission_state"] = SubmissionState.VERIFY
+        submission.submission_state = SubmissionState.VERIFY

-        embed = get_submission_embed(interaction.user.id)
+        embed = submission.get_embed()

        await channel.send(
            files=[await attch.to_file() for attch in interaction.message.attachments],
@@ -169,7 +129,7 @@ class SubmitButton(nextcord.ui.Button):
            content=f"Submission from {interaction.user.display_name}",
        )
        await interaction.message.edit(content=f"<@{interaction.user.id}> Submitted!", view=None)
-        submission_objects.pop(interaction.user.id)
+        submission_objects.remove_user_submission(interaction.user.id)


 ############ Submission Views ############
@@ -189,27 +149,26 @@ class SubmissionCreateButton(nextcord.ui.View):
        self, button: nextcord.ui.Button, interaction: nextcord.Interaction
    ):  # pylint: disable=unused-argument
        """Button for score submission."""
-        guild_id_str = str(interaction.guild.id)
-        guild_data = highscores_data[guild_id_str]
+        # 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

-        boss_name = highscores_message_map[guild_id_str][interaction.message.id]
-        channel = interaction.guild.get_channel(guild_data["submission_channel_id"])
+        table = highscores_message_map[interaction.guild.id][interaction.message.id]
+        channel = interaction.guild.get_channel(
+            highscores_data.get_guild(interaction.guild_id).submission_channel
+        )

        # a user should only have 1 submission active at once.
-        # submitting with dummy message_id until message created
-        # split username on pipe.
-        submission_objects[interaction.user.id] = {
-            "message_id": 0,
-            "submission_state": SubmissionState.CATEGORY,
-            "boss_name": boss_name,
-            "score": "",
-            "category": "",
-            "username": interaction.user.display_name.split("|")[0][
-                : guild_data["username_length"]
-            ],
-        }
+        # split username on pipe then limit length.
+        username: str = interaction.user.display_name.split("|")[0][
+            : highscores_data.get_guild(interaction.guild_id).username_length
+        ]
+        submission: Submission = Submission(interaction.guild_id, table, username)

-        embed = get_submission_embed(interaction.user.id)
+        submission_objects.add_submission(interaction.user.id, submission)
+
+        embed = submission.get_embed()

        submission_message = await channel.send(
            f"<@{interaction.user.id}>",
@@ -221,7 +180,7 @@ class SubmissionCreateButton(nextcord.ui.View):
        )

        # update the message_id once its created
-        submission_objects[interaction.user.id]["message_id"] = submission_message.id
+        submission.message_id = submission_message.id


 class SubmissionView(nextcord.ui.View):
@@ -232,17 +191,20 @@ class SubmissionView(nextcord.ui.View):
        bot: commands.Bot,
        submission_user: int,
        *,
-        timeout: Optional[float] = 180,
+        timeout: Optional[float] = 300,
    ):
        super().__init__(timeout=timeout)
        self._submission_user = submission_user
        self._bot = bot
-        self._state = submission_objects[self._submission_user]["submission_state"]
-        self._boss_name = submission_objects[self._submission_user]["boss_name"]
+        self._state = submission_objects.get_user_submission(self._submission_user).submission_state
+        self._boss_name = submission_objects.get_user_submission(self._submission_user).table
+        self._guild_id = submission_objects.get_user_submission(self._submission_user).guild_id

        # add items depending on given state
        if self._state is SubmissionState.CATEGORY:
-            self.add_item(SubmissionDropdown(bot, category_select_options(self._boss_name)))
+            self.add_item(
+                SubmissionDropdown(bot, category_select_options(self._guild_id, self._boss_name))
+            )
            self.add_item(CancelButton())
            self.add_item(NextButton(self._bot))
        elif (
@@ -257,4 +219,13 @@ class SubmissionView(nextcord.ui.View):
            self.add_item(SubmitButton(self._bot))

    async def interaction_check(self, interaction: nextcord.Interaction) -> bool:
-        return self._submission_user == interaction.user.id
+        check = self._submission_user == interaction.user.id
+
+        if not check:
+            await interaction.send("This is not your submission.", ephemeral=True)
+
+        return check
+
+    async def on_timeout(self) -> None:
+        # remove user from submission objects after time out. Allows user to start new submission.
+        submission_objects.remove_user_submission(self._submission_user)
@@ -1,6 +1,9 @@
 """View for verification buttons"""

 import nextcord
+from classes.score import Score, ScoreTime  # pylint: disable=import-error
+
+from highscores import highscores_data  # pylint: disable=import-error
 from utilities.utils import submit_score  # pylint: disable=import-error


@@ -29,8 +32,8 @@ class VerificationView(nextcord.ui.View):
        content = interaction.message.embeds[0].to_dict()

        for field in content["fields"]:
-            if field["name"] == "Boss":
-                boss_name = field["value"]
+            if field["name"] == "Table":
+                table = field["value"]
            elif field["name"] == "Category":
                category = field["value"]
            elif field["name"] == "Score":
@@ -39,7 +42,23 @@ class VerificationView(nextcord.ui.View):
                user = field["value"]

        try:
-            await submit_score(interaction, user, boss_name, category, score)
+            submission_guild = highscores_data.get_guild(interaction.guild_id)
+            submission_table = submission_guild.get_table(table)
+            submission_category = submission_table.get_category(category)
+            if submission_category.time_record:
+                submission_score: ScoreTime = ScoreTime(user)
+                submission_score.set_value_str(score)
+            else:
+                submission_score: Score = Score(user)
+                submission_score.set_value_str(score)
+
+            await submit_score(
+                interaction,
+                submission_guild,
+                submission_table,
+                submission_category,
+                submission_score,
+            )
            await interaction.message.edit(f"Approved by <@{interaction.user.id}>.", view=None)
        except UnboundLocalError:
            await interaction.send("Instruct user to submit with all fields.")
@@ -1,8 +1,8 @@
 {
    "tables": {
        "The Ambassador": [
-            "Kill Count",
-            "Kill Time",
+            "Solo Kill Count",
+            "Solo Kill Time",
            "Group Kill Count",
            "Group Kill Time",
            "Spooned Log"
@@ -21,8 +21,8 @@
            "Spooned Log"
        ],
        "Astellarn": [
-            "Kill Count",
-            "Kill Time",
+            "Solo Kill Count",
+            "Solo Kill Time",
            "Group Kill Count",
            "Group Kill Time",
            "Spooned Log"
@@ -42,8 +42,8 @@
            "Spooned Log"
        ],
        "Black Stone Dragon": [
-            "Kill Count",
-            "Kill Time",
+            "Solo Kill Count",
+            "Solo Kill Time",
            "Group Kill Count",
            "Group Kill Time",
            "Spooned Log"
@@ -65,8 +65,8 @@
            "Spooned Log"
        ],
        "Crassian Leviathan": [
-            "Kill Count",
-            "Kill Time",
+            "Solo Kill Count",
+            "Solo Kill Time",
            "Group Kill Count",
            "Group Kill Time",
            "Spooned Log"
@@ -160,8 +160,8 @@
            "Spooned Log"
        ],
        "Masuta the Ascended": [
-            "Kill Count",
-            "Kill Time",
+            "Solo Kill Count",
+            "Solo Kill Time",
            "Group Kill Count",
            "Group Kill Time",
            "Spooned Log"
@@ -193,15 +193,15 @@
            "Spooned Log"
        ],
        "The Sanctum Guardian": [
-            "Kill Count",
-            "Kill Time",
+            "Solo Kill Count",
+            "Solo Kill Time",
            "Group Kill Count",
            "Group Kill Time",
            "Spooned Log"
        ],
        "Seiryu the Azure Serpent": [
-            "Kill Count",
-            "Kill Time",
+            "Solo Kill Count",
+            "Solo Kill Time",
            "Group Kill Count",
            "Group Kill Time",
            "Spooned Log"
@@ -331,5 +331,5 @@
            "is_time_record": false
        }
    },
-    "highscore_size": 3
-}
+    "table_size": 3
+}
@@ -4,14 +4,14 @@ main file for pvm-highscores bot

 import logging
 import os
+import sys

 import nextcord
 from nextcord.ext import commands

 import config
-from utilities.data_storage import open_highscores_config
-from utilities.data_storage import open_highscores_data
-from utilities.data_storage import create_message_map
+from classes.highscores_data import HighscoresData
+from classes.submission import SubmissionMap

 logger = logging.getLogger("nextcord")
 logger.setLevel(logging.DEBUG)
@@ -20,15 +20,24 @@ handler.setFormatter(logging.Formatter("%(asctime)s:%(levelname)s:%(name)s: %(me
 logger.addHandler(handler)


-highscores_config = open_highscores_config()
-highscores_data = open_highscores_data()
-highscores_message_map = create_message_map(highscores_data)
+highscores_data: HighscoresData = HighscoresData()
+highscores_message_map = {}

-submission_objects: dict = {}
+for guild in highscores_data.guilds:
+    highscores_message_map[guild.guild_id] = {}
+    for table in guild.tables:
+        highscores_message_map[guild.guild_id][table.message_id] = table.name
+
+submission_objects: SubmissionMap = SubmissionMap()


 def main():
    """Main function for bot."""
+    min_python_version = (3, 7)
+    if sys.version_info < min_python_version:
+        print("ERROR: Python version must be >= 3.7")
+        sys.exit()
+
    # Allows privledged intents for monitoring members joining, roles editing, and role assignments
    # These need to be enabled in the developer portal as well
    intents = nextcord.Intents.default()
@@ -42,15 +51,9 @@ def main():
    # To enable the members priveleged intent:
    # intents.members = True

-    # Set custom status to "Listening to ?help"
-    activity = nextcord.Activity(
-        type=nextcord.ActivityType.listening, name=f"{config.BOT_PREFIX}help"
-    )
-
    bot = commands.Bot(
        commands.when_mentioned_or(config.BOT_PREFIX),
        intents=intents,
-        activity=activity,
    )

    # Get the modules of all cogs whose directory structure is ./cogs/<module_name>
@@ -1,79 +0,0 @@
-"""Functions for retreiving and storing highscores data and configurations."""
-
-import os
-import json
-
-HIGHSCORES_CONFIG_FILE = "highscores_config.json"
-HIGHSCORES_DATA_FILE = "highscores_data.json"
-
-
-def create_highscore_skeleton() -> dict:
-    """
-    Creates a skeleton entry for new highscores data
-
-    @return: dict skeleton entry
-    """
-    # create the dict
-    skeleton = {"highscore_channel_id": -1, "verification_channel_id": -1, "username_length": 12}
-    config: dict = open_highscores_config()
-    skeleton["tables"] = {}
-    for boss, categories in config["tables"].items():
-        skeleton["tables"][boss] = {"message_id": 0}
-        boss_categories = {}
-        for category in categories:
-            rank_list = []
-            boss_categories[category] = rank_list
-        skeleton["tables"][boss]["categories"] = boss_categories
-
-    return skeleton
-
-
-def create_message_map(data: dict):
-    """
-    Creates a message map from input highscores data.
-
-    @param data: highscores_data dict to create map from.
-    @return: dict message_map of message to boss.
-    """
-
-    message_map = {}
-
-    # guild id will be a string. Json object keys are strings.
-    for guild, guild_scores in data.items():
-        message_map[guild] = {}
-        for boss, info in guild_scores["tables"].items():
-            message_map[guild][info["message_id"]] = boss
-
-    return message_map
-
-
-def open_highscores_config():
-    """
-    Opens the highscores config file and returns.
-    @return: dict of highscores config.
-    """
-    # Load bot config
-    with open(HIGHSCORES_CONFIG_FILE, encoding="utf-8", mode="r") as file:
-        return json.load(file)
-
-
-def open_highscores_data():
-    """
-    Opens a highscores_data.json file if one exists, otherwise returns empty dict.
-    @return: dict of highscores data.
-    """
-    if os.path.exists(HIGHSCORES_DATA_FILE):
-        with open(HIGHSCORES_DATA_FILE, encoding="utf-8", mode="r") as file:
-            data = json.load(file)
-    else:
-        data = {}
-    return data
-
-
-def save_highscores_data(data: dict):
-    """
-    Saves the highscores data dict into a json file.
-    @param data: dict of highscores data.
-    """
-    with open(HIGHSCORES_DATA_FILE, encoding="utf-8", mode="w") as file:
-        file.write(json.dumps(data, indent=4))
@@ -3,46 +3,53 @@ Contains various utlity functions for highscores bot
 """

 import nextcord
-from highscores import highscores_config  # pylint: disable=import-error
-from highscores import highscores_data  # pylint: disable=import-error
-from highscores import highscores_message_map  # pylint: disable=import-error
-from utilities.data_storage import save_highscores_data  # pylint: disable=import-error
+from highscores import highscores_data, highscores_message_map  # pylint: disable=import-error
+from classes.score import Score  # pylint: disable=import-error
+from classes.guild import Guild  # pylint: disable=import-error
+from classes.category import Category  # pylint: disable=import-error
+from classes.table import Table  # pylint: disable=import-error


-def format_highscore_message(boss_name: str, guild_data: dict):
+def format_highscore_message(guild: Guild, table: Table) -> str:
    """
-    returns a formatted string for a boss's highscore
-    @param boss: the dictionary object for the boss
-    @param guild_data: the guild's highscore data
-    @return the formatted string
+    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:
+        guild (Guild): Guild object that is posting the message.
+        table (Table): Table object that contains the contents of the message.
+
+    Returns:
+        str: Formatted string for discord message
    """
-    ret_string = f"**{boss_name}**\n```"
-    boss_data = guild_data["tables"][boss_name]
+    ret_string = f"**{table.name}**\n```"

    # Gather all categories and add to string
-    for key, value in boss_data["categories"].items():
-        ret_string += f"{key}".ljust(26, " ")
+    for category in table.categories:
+        ret_string += f"{category.name}".ljust(26, " ")
    ret_string += "\n"

-    highscore_size = highscores_config["highscore_size"]
-
    # list rankings in a single line. Start with first place for each category and then continue
-    for i in range(highscore_size):
-        for key, value in boss_data["categories"].items():
-            if len(value) > i:
-                score_pair = value[i]
-
+    for i in range(table.size):
+        for category in table.categories:
+            if len(category.scores) > i:
                # pad username to max length.
-                username: str = score_pair[0].ljust(guild_data["username_length"], " ")
-                score: str = str(score_pair[1])
+                # have to convert category.scores into list to make it subscriptable. no idea why.
+                username: str = list(category.scores)[i].user.ljust(guild.username_length, " ")

-                if highscores_config["categories"][key]["is_time_record"]:
-                    # pad score to correct length
-                    # MM:SS.ms is 7 characters long
-                    score = score.ljust(7, " ")
+                score: str = list(category.scores)[i].get_str()

-                line_str = f"{i+1}: {username} - "
-                ret_string += line_str + score.rjust(26 - len(line_str) - 1) + " "
+                # pad score to correct length
+                # MM:SS.ms is 7 characters long
+                if category.time_record:
+                    # if there are single digit minutes, add a space for formatting.
+                    if score.find(":") and len(score.split(":", maxsplit=1)[0]) < 2:
+                        score = " " + score
+                else:
+                    score = score.rjust(7, " ")
+
+                ret_string += f"{i+1}: {username} - {score}".ljust(26, " ")
            else:
                ret_string += f"{i+1}: submit your score".ljust(26, " ")
        ret_string += "\n"
@@ -51,19 +58,23 @@ def format_highscore_message(boss_name: str, guild_data: dict):


 async def send_highscore_message(
-    channel: nextcord.TextChannel, boss_name: str, guild_data: dict
+    channel: nextcord.TextChannel, guild: Guild, table: Table
 ) -> nextcord.Message:
    """
-    Function takes care of checking if a message exists for a boss, then
-    creating and sending/editing the message
-    @param channel: the channel to send the message in/search for message id
-    @param boss: the boss to send the message about
-    @param guild_data: the guild's highscore data
-    @return: The nextcord message
-    """
-    highscore_string = format_highscore_message(boss_name, guild_data)
+    Function takes care of checking if a message exists for a table.
+    Creates and sends/edits the message.

-    message_id = guild_data["tables"][boss_name]["message_id"]
+    Args:
+        channel (nextcord.TextChannel): Discord channel object where message is sent
+        guild (Guild): Guild object for Guild that is posting the message
+        table (Table): Table to post to the message
+
+    Returns:
+        nextcord.Message: Message object that was posted with table contents
+    """
+    highscore_string = format_highscore_message(guild, table)
+
+    message_id = table.message_id
    try:
        message: nextcord.Message = await channel.fetch_message(message_id)
        await message.edit(content=highscore_string)
@@ -71,92 +82,42 @@ async def send_highscore_message(
        # message doesn't exist.
        message: nextcord.Message = await channel.send(highscore_string)
        message_id = message.id
-        guild_data["tables"][boss_name]["message_id"] = message_id
+        table.message_id = message_id
        # save message -> boss_name in message_map
        # get guild id from channel
        # channel should come from the guild that is requesting this highscores message anyways.
-        highscores_message_map[str(channel.guild.id)][message_id] = boss_name
+        # check if guild is in message map already
+        if not channel.guild.id in highscores_message_map:
+            highscores_message_map[channel.guild.id] = {}
+        highscores_message_map[channel.guild.id][message_id] = table.name

    return message


 async def submit_score(
-    interaction: nextcord.Interaction, user: str, boss_name: str, category: str, score: str
-):
+    interaction: nextcord.Interaction, guild: Guild, table: Table, category: Category, score: Score
+) -> None:
    """
-    Adds a score to the high scores and sorts. Removes a score if larger than size limit.
-    @param boss: the boss to add score to
-    @param category: the category to add score to
-    @param user: user who submitted score
-    @param score: score to add
+    Adds passed score to table. Then updates table message by calling send_highscore_message.
+    Ensures that a highscores channel exists.
+
+    Args:
+        interaction (nextcord.Interaction): Interaction that caused the score submission
+        guild (Guild): Guild to submit score to
+        table (Table): Table to submit score to
+        category (Category): Category to submit score to
+        score (Score): Score to submit
    """

-    boss_category_config = highscores_config["categories"][category]
-    guild_data = highscores_data[str(interaction.guild.id)]
-
-    # create score tuple for either time or int
-    # define sort index
-    if boss_category_config["is_time_record"]:
-        if score.find(":") == -1:
-            score_seconds = float(score)
-        else:
-            minutes = score.split(":")[0]
-            seconds = score.split(":")[1]
-            score_seconds = int(minutes) * 60 + float(seconds)
-        score_tuple = (user, score, score_seconds)
-        sort_index = 2
-
-    else:
-        score_tuple = (user, int(score))
-        sort_index = 1
-
-    scores: "list[tuple]" = guild_data["tables"][boss_name]["categories"][category]
-
-    # if user is in an existing tuple, delete it.
-    users_scores: "list[tuple]" = [score_tuple]
-    for tup in scores:
-        if user == tup[0]:
-            # Add tup to users_scores, remove from scores
-            users_scores.append(tup)
-
-    # sort users_scores
-    users_scores.sort(
-        key=lambda x: x[sort_index],
-        reverse=not boss_category_config["ascending"],
-    )
-
-    for index, tup in enumerate(users_scores):
-        if index == 0:
-            # first score is the best score.
-            if tup not in scores:
-                scores.append(tup)
-        else:
-            # discard all other scores from scores list.
-            if tup in scores:
-                scores.remove(tup)
-
-    # sort scores.
-    scores.sort(
-        key=lambda x: x[sort_index],
-        reverse=not boss_category_config["ascending"],
-    )
-
-    # enforce highscore size
-    while len(scores) > highscores_config["highscore_size"]:
-        scores.pop()
-    guild_data["tables"][boss_name]["categories"][category] = scores
+    category.add_score(score)
+    highscores_data.save_guild_data(guild)

    # edit message
-    highscore_channel_id = guild_data["highscore_channel_id"]
-    print(f"Editting message {highscore_channel_id}")
-    channel = interaction.guild.get_channel(highscore_channel_id)
+    print(f"Editting message {guild.highscore_channel}")
+    channel = interaction.guild.get_channel(guild.highscore_channel)

    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, boss_name, guild_data)
-
-    # save data
-    highscores_data[str(interaction.guild.id)] = guild_data
-    save_highscores_data(highscores_data)
+    await send_highscore_message(channel, guild, table)
Author	SHA1	Message	Date
alwayscompiling	0eb332aefd	Added verify and submission register subcommands. Removed bot argument from Register class.	2022-08-06 22:21:08 -04:00
alwayscompiling	ff07787a9a	Create register group and highscore slash subcommand.	2022-08-06 20:14:30 -04:00
alwayscompiling	b5959ccc33	Change constructor of score. Create new function to add score value from a string.	2022-08-06 17:32:17 -04:00
alwayscompiling	b80f160914	Update verification view to use Table instead of Boss.	2022-08-06 16:55:06 -04:00
alwayscompiling	3b866be3ab	Corrected typo in submission_state setter.	2022-08-06 16:45:05 -04:00
alwayscompiling	e55b22c821	Easier to read submission access.	2022-08-06 16:41:50 -04:00
alwayscompiling	f06e6f1e1e	Create function to know if a user has a submission.	2022-08-06 16:30:49 -04:00
alwayscompiling	5f3e7361b4	Convert old submission_objects to new class.	2022-08-06 16:30:31 -04:00
alwayscompiling	835611a11e	Created submission classes.	2022-08-06 16:10:19 -04:00
alwayscompiling	ee9a23ca79	Renamed data folder to classes.	2022-08-06 14:59:58 -04:00
alwayscompiling	448bed17ec	Have to pass guild object to save function.	2022-08-04 11:34:51 -04:00
alwayscompiling	b4d0f8a15e	Save data after posting messages.	2022-08-04 11:22:50 -04:00
alwayscompiling	72a97f6cb7	Correct config creation.	2022-08-04 11:15:27 -04:00
alwayscompiling	8aadf07968	Added asending and time record setters.	2022-08-04 11:06:36 -04:00
alwayscompiling	a6f98d11ab	Added temporary config handling.	2022-08-04 11:06:18 -04:00
alwayscompiling	4ee0593619	Edit category constructor to allow for empty objects.	2022-08-04 10:38:45 -04:00
alwayscompiling	d4db9b51f0	Moved table size to table class. Edited table constructor.	2022-08-04 10:33:34 -04:00
alwayscompiling	f67eb75c7b	Add warning for posting without tables.	2022-08-04 10:29:14 -04:00
alwayscompiling	6f4322bf6a	Added a to_str function for all classes. __str__ function uses it. highscores_data uses the to_str function for saving.	2022-08-03 22:35:27 -04:00
alwayscompiling	66ace947c6	Saving guild after modification.	2022-08-03 22:21:49 -04:00
alwayscompiling	4d9c70bf09	Update saving functions.	2022-08-03 22:16:43 -04:00
alwayscompiling	4c944c8323	pylint line length.	2022-08-03 20:08:32 -04:00
alwayscompiling	b65254c2cc	Runtime error fixes.	2022-08-03 20:03:48 -04:00
alwayscompiling	5b3c9ef247	Somehow didn't finish guilds function.	2022-08-03 19:32:37 -04:00
alwayscompiling	027da38574	Update utils function args to use new data classes instead of various args.	2022-08-03 19:28:47 -04:00
alwayscompiling	80e4602621	Update submissin cog to new data class. Also clean up import lists.	2022-08-02 21:52:12 -04:00
alwayscompiling	07310c804a	Remove score command. It isn't used.	2022-08-02 21:41:13 -04:00
alwayscompiling	4641ce4048	Update register command to use data class.	2022-08-02 21:40:27 -04:00
alwayscompiling	142842a36b	Update post highscores to new data class.	2022-08-02 21:36:17 -04:00
alwayscompiling	6371fc4e8c	Update message listener to new data classes.	2022-08-02 21:29:57 -04:00
alwayscompiling	3fac5f7a06	Update guild listener command to new data classes.	2022-08-02 21:23:16 -04:00
alwayscompiling	80f3966d39	Update delete scores command.	2022-08-02 21:21:36 -04:00
alwayscompiling	69a439d13a	Correct message map creation.	2022-08-02 16:43:15 -04:00
alwayscompiling	251ac2cf47	Update highscores.py to use new data classes.	2022-08-02 16:41:46 -04:00
alwayscompiling	2dc0350213	Idk how the merge messed up, but fixed the bad merge.	2022-08-02 16:36:50 -04:00
alwayscompiling	7e40937cdd	Merge branch '25-data-class' of github.com:alwayscompiling/pvm-highscores into 25-data-class	2022-08-02 16:33:35 -04:00
alwayscompiling	761a7df29f	Constructor and string function fixes. Ignored new data dir.	2022-08-02 16:30:30 -04:00
alwayscompiling	b3a84fc3a8	Add str function for highscores data.	2022-08-02 16:20:56 -04:00
alwayscompiling	262bcd07b9	Update highscores_data to be an overarching class for all data.	2022-08-02 16:16:45 -04:00
alwayscompiling	8ca77d93b3	Update highscores_data to be an overarching class for all data.	2022-08-02 16:13:08 -04:00
alwayscompiling	1b4f0362b5	Renamed runescape example config.	2022-08-01 22:50:01 -04:00
alwayscompiling	ce60288892	Add highscore size to guild class.	2022-08-01 22:48:23 -04:00
alwayscompiling	2515b90497	redo guild docstrings.	2022-08-01 22:38:32 -04:00
alwayscompiling	3ce9f8090f	Correct from dict wording.	2022-08-01 22:29:30 -04:00
alwayscompiling	68da97e138	Redo table docstrings.	2022-08-01 22:23:38 -04:00
alwayscompiling	ef28b97a1b	get user score was using wrong variable.	2022-08-01 22:22:16 -04:00
alwayscompiling	e43a0a8977	Redo category docstrings.	2022-08-01 22:17:52 -04:00
alwayscompiling	2ee2d3405e	Redo score docstrings.	2022-08-01 22:06:54 -04:00
alwayscompiling	af204a3156	Correct sort scores value.	2022-08-01 21:56:23 -04:00
alwayscompiling	109b22be62	Add get_table function.	2022-08-01 21:21:57 -04:00
alwayscompiling	aa4b06c125	Correct return type of tables.	2022-08-01 21:17:26 -04:00
alwayscompiling	96fce1d661	Clarified to_dict function description.	2022-08-01 21:12:46 -04:00
alwayscompiling	3d471198f5	Created rest of guild functions.	2022-08-01 21:09:03 -04:00
alwayscompiling	05d0653a5b	Create guild class.	2022-07-31 22:45:57 -04:00
alwayscompiling	6758f4e90d	Changing from_dict to classmethod.	2022-07-31 22:14:53 -04:00
alwayscompiling	6e6b57c49c	Create table class.	2022-07-31 12:07:07 -04:00
alwayscompiling	b4f72b9528	Renamed scores to scores_map to avoid confusion.	2022-07-31 11:51:50 -04:00
alwayscompiling	cd81ee3140	Change score score to be score value.	2022-07-31 10:57:45 -04:00
alwayscompiling	6ddba14908	Change str function to use json string dump.	2022-07-31 10:19:23 -04:00
alwayscompiling	0fc0fc33da	Filled out to and from dict functions and a few others.	2022-07-30 23:12:40 -04:00
alwayscompiling	529761b45f	Remove optional on score.	2022-07-30 22:43:11 -04:00
alwayscompiling	bac64110c1	Add category class.	2022-07-30 22:31:40 -04:00
alwayscompiling	d04de253e7	Add str function.	2022-07-30 22:15:58 -04:00
alwayscompiling	8c7a801800	Small description change.	2022-07-30 21:58:10 -04:00
alwayscompiling	01df80d358	Correcting time string.	2022-07-30 21:53:29 -04:00
alwayscompiling	06248cfe6c	Using property decorators.	2022-07-30 21:12:36 -04:00
alwayscompiling	a3af93d4bc	Create Score class.	2022-07-30 17:09:44 -04:00
alwayscompiling	646ee0274b	Move highscores_data to new location.	2022-07-30 16:34:33 -04:00
alwayscompiling	fe0a74cfc4	Extend submission timeout. Remove submission object on submission timeout. Also Let user know when it isn't their submission.	2022-07-30 16:19:44 -04:00
alwayscompiling	5bed587da9	Fixing configs for elite dungeon bosses.	2022-07-30 10:56:21 -04:00
alwayscompiling	f7a40f83a9	Birthday troll.	2022-07-29 22:45:40 -04:00
alwayscompiling	a66bc4982f	on_guild_join needs 2 parameters.	2022-07-29 22:45:21 -04:00
alwayscompiling	04051eeacc	Merge branch '14-score-entries-as-dictsjson-objects' into develop	2022-07-29 16:49:50 -04:00
alwayscompiling	f33dc8ce37	Skeleton needs to have dict for category scores.	2022-07-29 16:48:25 -04:00
alwayscompiling	306f983c8e	Had to change access to scores. Somewhat weird due to them being dicts and dicts being difficult to access by index.	2022-07-29 16:35:45 -04:00
alwayscompiling	9e9d616814	Change tuple to list. Its stored as a list anyways.	2022-07-29 16:16:16 -04:00
alwayscompiling	5a09beea31	Convert add_score to have scores as a dict.	2022-07-29 15:56:37 -04:00
alwayscompiling	8c2b3fa487	Server count on all presense strings.	2022-07-29 15:10:41 -04:00
alwayscompiling	62e89960f7	Changed presence update functionability to a cog. Randomly chooses a string and updates the presence every 2 minutes.	2022-07-29 15:08:42 -04:00
alwayscompiling	e2b0c0ea89	Enforcing python version because ordered dicts in 3.7 is required.	2022-07-29 14:27:10 -04:00
alwayscompiling	3eed30567d	Fixed single digit second submissions. Covered bases to ensure time format is consistant.	2022-07-29 14:12:58 -04:00
alwayscompiling	565babd1d3	Correct submission listener usage of HighscoresData.	2022-07-28 11:14:38 -04:00
alwayscompiling	455b51a998	Remove outdated import.	2022-07-28 11:02:47 -04:00
alwayscompiling	f136181216	Message map has guild id as an int. Update submission view to use HighscoresData.	2022-07-28 11:01:40 -04:00
alwayscompiling	463ef48052	Move message map creation to highscores.py. Was a circular import.	2022-07-28 10:41:10 -04:00
alwayscompiling	64004329da	Add HighscoresData to register command. Add channel setting functions.	2022-07-28 10:25:56 -04:00
alwayscompiling	f497928054	Get table names from data. Update post scores to use HighscoresData class.	2022-07-28 10:17:46 -04:00
alwayscompiling	0911ebfa45	Updated guild listener to HighscoresData class.	2022-07-27 22:32:28 -04:00
alwayscompiling	beedf946c9	Update delete scores to new HighscoresData class.	2022-07-27 22:27:27 -04:00
alwayscompiling	5b31314f02	Fill out HighscoreData class with access functions for utils.py.	2022-07-27 22:15:06 -04:00
alwayscompiling	4b15fef30c	Set highscore_data type.	2022-07-27 21:59:57 -04:00
alwayscompiling	e11a86af7b	Update highscores.py to use HighscoreData class.	2022-07-27 20:48:04 -04:00
alwayscompiling	f4f8f426d0	Move create_message_map to here.	2022-07-27 20:44:35 -04:00
alwayscompiling	b8eb84165e	Create new class for storing data.	2022-07-27 20:44:07 -04:00
alwayscompiling	273ff757af	Correct delete scores description.	2022-07-26 22:44:32 -04:00
alwayscompiling	f84e2eef29	Preventing user from having multiple submissions.	2022-07-26 22:17:24 -04:00
alwayscompiling	b4eb5ab6d1	Removed deleting of scores pushed off table.	2022-07-26 22:12:12 -04:00
alwayscompiling	1ae6a4a223	Ensure formatting lines up times and right justifies int scores.	2022-07-26 22:09:35 -04:00
alwayscompiling	e1a429c42a	Trim leading 0s from time scores.	2022-07-26 21:48:31 -04:00
alwayscompiling	790e8ca50f	Create delete-score command.	2022-07-26 21:35:56 -04:00
alwayscompiling	7ba43ea4f4	Creating message map entry if guild id isn't there already.	2022-07-26 21:22:12 -04:00
alwayscompiling	39c858af64	Correct regex to ensure start and end of string.	2022-07-23 15:23:16 -04:00