def __init__(self):
if Config.__instance is not None:
raise Exception("Error: Cannot create another instance of Config, one already exists.")
else:
Config.__instance = self
with open(str(get_project_dir() / "bin/config.yml")) as f:
self.CONF = yaml.load(f, Loader=yaml.FullLoader)
def update_config_property_and_write(key: str, value: object):
if Config.__instance is None:
Config()
Config.__instance.CONF = Config.__update_config_property_and_write_helper(key.split("/"), value,
Config.__instance.CONF)
with open(str(get_project_dir() / "bin/config.yml"), "w+") as f:
yaml.dump(Config.__instance.CONF, f)
def __init__(self, bot: commands.Bot):
self.bot = bot
# core.model.tenman
self.__ongoing = None
# Message for displaying the current status of the tenman (teams, map picks, etc.)
self.__status_message = None
# Print help messages to help new users know which commands need to come next
self.__display_help = False
with open(str(get_project_dir() /
"bin/resources/tenman/resources.yml")) as f:
self.__resources = yaml.load(f, Loader=yaml.FullLoader)
LOGGER.info("Initialized ten man command cog.")
async def get_leaderboard(self, ctx, *args):
try:
parsed_args = ServerArgParsers.LEADERBOARD_ARG_PARSER.parse_known_args(args)[0]
except ArgumentParserError as e:
raise commands.ArgumentParsingError(message=e.args[0])
if parsed_args.mobile:
headers = ["N", "S", "CS", "LS"]
else:
headers = ["Name", "Score", "Current Streak", "Longest Streak"]
emoji = find(lambda em: str(em) == parsed_args.emoji, ctx.guild.emojis)
try:
if emoji.name not in Config.get_config_property("server", "leaderboard", "emojiMap").keys():
raise commands.BadArgument("There is no leaderboard associated with the emoji.")
relative_path = "{0}/leaderboards/{1}/{2}.json".format(Config.get_config_property("saveDir"),
str(ctx.guild.id), emoji.name)
with open(str(get_project_dir() / relative_path)) as f:
leaderboard_json = json.load(f)
entries = sorted(leaderboard_json, key=lambda e: (leaderboard_json[e]["score"],
leaderboard_json[e]["current_streak"], leaderboard_json[e]["longest_streak"]),
reverse=True)
except AttributeError as e:
LOGGER.error("ServerCog::leaderboard - Called with default emoji.")
raise commands.BadArgument("Leaderboards don't exist for default emojis.")
except FileNotFoundError as e:
LOGGER.error("ServerCog::leaderboard - No leaderboard data found for called emoji")
raise commands.BadArgument("No leaderboard data found for called emoji.")
try:
entries = entries[0:int(parsed_args.top)]
except TypeError:
pass
except IndexError:
LOGGER.warning("Specified a value that was larger than the amount of users with scores")
pass
except ValueError:
LOGGER.error("ServerCog::leaderboard - " + parsed_args.top + " is not an int")
raise commands.BadArgument("Bad argument for top parameter. Expected integer.")
table = [[find(lambda u: str(u.id) == e, ctx.guild.members).name, leaderboard_json[e]["score"],
leaderboard_json[e]["current_streak"], leaderboard_json[e]["longest_streak"]] for e in entries]
await ctx.channel.send("{0}*** Leaderboard ***{0}\n```{1}```".format(str(emoji), tabulate(table,
headers=headers)))
def process_entries(self):
LOGGER.info("LeaderboardHandler::process_entries - Processing leaderboard entries")
emoji_time_dict = Config.get_config_property("server", "leaderboard", "emojiMap")
today = datetime.now()
if today.day == 1:
self.__process_score_reset()
for emoji in emoji_time_dict.keys():
leaderboard_path = str(get_project_dir() / "{0}/leaderboards/307026836066533377/{1}.json"
.format(Config.get_config_property("saveDir"), emoji))
leaderboard_json = read_json_safe(leaderboard_path)
entries = [entry for entry in self.__unprocessed_entries if entry["emote"] == emoji]
time = datetime.strptime(emoji_time_dict[emoji], "%H:%M")
for entry in entries:
if (entry["timestamp"].hour == time.hour or entry["timestamp"].hour == time.hour + 12) and entry["timestamp"].minute == time.minute:
if entries.index(entry) == 0:
score = Config.get_config_property("server", "leaderboard", "scores", "max")
else:
score = Config.get_config_property("server", "leaderboard", "scores", "default")
else:
score = Config.get_config_property("server", "leaderboard", "scores", "min")
entry["timestamp"] = None
try:
user_score = leaderboard_json[str(entry["user_id"])]
except KeyError:
user_score = {
"score": 0,
"current_streak": 1,
"longest_streak": 0,
"timestamp": None
}
if user_score["score"] + score < 0:
user_score["score"] = 0
else:
user_score["score"] = user_score["score"] + score
try:
last_timestamp = datetime.strptime(user_score["timestamp"], "%m/%d/%Y")
except TypeError:
last_timestamp = None
try:
user_score["timestamp"] = datetime.strftime(entry["timestamp"], "%m/%d/%Y")
except TypeError:
user_score["timestamp"] = None
try:
if entry["timestamp"] is None:
user_score["current_streak"] = 0
elif (entry["timestamp"].date() - last_timestamp.date()).days == 1:
user_score["current_streak"] = user_score["current_streak"] + 1
elif (entry["timestamp"].date() - last_timestamp.date()).days > 1:
user_score["current_streak"] = 1
except AttributeError:
pass
if user_score["current_streak"] > user_score["longest_streak"]:
user_score["longest_streak"] = user_score["current_streak"]
leaderboard_json[str(entry["user_id"])] = user_score
self.__unprocessed_entries.remove(entry)
current_day = datetime.now().date()
for key in leaderboard_json:
try:
score = leaderboard_json[key]
if (current_day - datetime.strptime(score["timestamp"], "%m/%d/%Y").date()).days > 1:
score["current_streak"] = 0
leaderboard_json[key] = score
except (KeyError, TypeError):
pass
with open(leaderboard_path, "w") as f:
json.dump(leaderboard_json, f, indent=4)
import logging
from discord.ext import commands
from core.useraccounts import get_account
from _global.config import Config
from utilities.misc import get_project_dir
LOGGER = logging.getLogger("goldlog")
SERVER_SAVE_FILE = get_project_dir() / "{0}/server.pkl".format(Config.get_config_property("saveDir"))
class UserAccountCog(commands.Cog):
def __init__(self, bot):
self.bot = bot
LOGGER.info("Initialized user account command cog.")
@commands.command(name="set_friend_code")
async def set_friend_code(self, ctx, friend_code: str):
account = get_account(ctx.message.author)
if account.set_friend_code(friend_code):
await ctx.channel.send(content="Your friend code has been set!")
LOGGER.info("UserCommand::get_friend_code called for " + ctx.message.author.name)
else:
LOGGER.warning("UserCommand::set_friend_code call failed for " + str(ctx.message.author.id) +
". Invalid formatting")
raise commands.BadArgument("Incorrect Friend Code formatting. Expecting formats:\n"
"`1234-1234-1234`\n`SW-1234-1234-1234`\n`DS-1234-1234-1234`", friend_code)
@commands.command(name="get_friend_code")
async def get_friend_code(self, ctx):
if len(ctx.message.mentions) < 1: