227 lines
7.6 KiB
Python
227 lines
7.6 KiB
Python
"""Class and functions for storing and retrieving highscores data."""
|
|
|
|
import os
|
|
import json
|
|
|
|
HIGHSCORES_CONFIG_FILE = "highscores_config.json"
|
|
HIGHSCORES_DATA_FILE = "highscores_data.json"
|
|
|
|
|
|
class HighscoresData:
|
|
"""Class for storing and retrieving highscores data."""
|
|
|
|
def __init__(self) -> None:
|
|
self._config = open_highscores_config()
|
|
self._data = open_highscores_data()
|
|
|
|
def add_new_server(self, guild_id: int):
|
|
"""
|
|
Creates new skeleton data dict and adds to self for new guild.
|
|
|
|
@param guild_id: guild_id to add.
|
|
"""
|
|
# 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
|
|
|
|
self._data[str(guild_id)] = skeleton
|
|
|
|
def add_score(
|
|
self, guild_id: int, boss_name: str, category: str, user: str, score: str
|
|
) -> None:
|
|
"""
|
|
Adds a new score to guilds highscore data.
|
|
Ensures that there is no user duplicate and then sorts the scores
|
|
|
|
@param guild_id: guild id to retrieve from.
|
|
@param boss_name: boss to add score to.
|
|
@param category: category to add score to.
|
|
@param user: user that submitted score.
|
|
@param score: score to add.
|
|
"""
|
|
scores: "list[tuple]" = self._data[str(guild_id)]["tables"][boss_name]["categories"][
|
|
category
|
|
]
|
|
ascending: bool = self._config["categories"][category]["ascending"]
|
|
time_record: bool = self._config["categories"][category]["is_time_record"]
|
|
|
|
# create score tuple for either time or int
|
|
# define sort index
|
|
if 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
|
|
|
|
# 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 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 ascending,
|
|
)
|
|
|
|
self._data[str(guild_id)]["tables"][boss_name]["categories"][category] = scores
|
|
save_highscores_data(self._data)
|
|
|
|
def get_categories_data(self, guild_id: int, table: str) -> "list[tuple]":
|
|
"""
|
|
Returns categories data in a list of tuples. Calls dict function items().
|
|
|
|
@param guild_id: guild's id to retrieve from.
|
|
@param table: table to get category data from
|
|
@returns: list of tuples containing all category and relative score data.
|
|
"""
|
|
return self._data[str(guild_id)][table]["categories"].items()
|
|
|
|
def get_config_highscore_size(self) -> int:
|
|
"""
|
|
Gets the defined size of highscore for config.
|
|
|
|
@returns: int highscore size
|
|
"""
|
|
return self._config["highscore_size"]
|
|
|
|
def get_guild_channel_id(self, guild_id: int) -> int:
|
|
"""
|
|
Returns the channel id to post highscore messages to.
|
|
|
|
@param guild_id: guild id to retrieve from
|
|
"""
|
|
return self._data[str(guild_id)]["highscore_channel_id"]
|
|
|
|
def get_guild_username_length(self, guild_id: int) -> int:
|
|
"""
|
|
Returns username length as set by each guild.
|
|
|
|
@param guild_id: guild id to retrieve from.
|
|
@returns: int of username length.
|
|
"""
|
|
return self._data[str(guild_id)]["username_length"]
|
|
|
|
def get_table_message_id(self, guild_id: int, table: str) -> int:
|
|
"""
|
|
Returns the message id for given guild's table.
|
|
|
|
@param guild_id: guild id to retrieve from.
|
|
@param table: the table to retreive from.
|
|
@returns: int id of message for table's highscores.
|
|
"""
|
|
return self._data[str(guild_id)]["tables"][table]["message_id"]
|
|
|
|
def remove_guild(self, guild_id: int, guild_name: str) -> None:
|
|
"""
|
|
Removes a guild's data from object. Saves backup.
|
|
|
|
@param guild_id: guild id to remove.
|
|
@param guild_name: name of guild for backup.
|
|
"""
|
|
old_data = self._data.pop(str(guild_id))
|
|
save_highscores_data(self._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))
|
|
|
|
def reset_guild_data(self, guild_id: int) -> None:
|
|
"""
|
|
Resets highscore data for a guild. Should only be used for development really...
|
|
|
|
@param guild_id: guild id to reset data for
|
|
"""
|
|
guild_data: dict = self._data[str(guild_id)]
|
|
|
|
for boss, boss_data in guild_data["tables"].items():
|
|
for category, category_data in boss_data["categories"].items():
|
|
category_data = []
|
|
boss_data["categories"][category] = category_data
|
|
guild_data["tables"][boss] = boss_data
|
|
self._data[str(guild_id)] = guild_data
|
|
save_highscores_data(self._data)
|
|
|
|
def set_table_message_id(self, guild_id: int, table: str, message_id: int) -> None:
|
|
"""
|
|
Sets the message id for given guild's table.
|
|
Saves highscores data.
|
|
|
|
@param guild_id: guild id to retrieve from.
|
|
@param table: the table to retreive from.
|
|
@param message_id: message id to set.
|
|
"""
|
|
self._data[str(guild_id)]["tables"][table]["message_id"] = message_id
|
|
save_highscores_data(self._data)
|
|
|
|
|
|
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))
|