async def display_diff(db: DatabaseManager, id_discord_server: int, username1: str, username2: str) \
-> List[Dict[str, Optional[str]]]:
if not await db.user_exists(id_discord_server, username1):
tosend = f'User {username1} is not in team.'
tosend_list = [{'user': username1, 'msg': tosend}]
return tosend_list
if not await db.user_exists(id_discord_server, username2):
tosend = f'User {username2} is not in team.'
tosend_list = [{'user': username2, 'msg': tosend}]
return tosend_list
database_users = await db.select_users(id_discord_server)
user1 = db.find_user(database_users, id_discord_server, username1)
user2 = db.find_user(database_users, id_discord_server, username2)
solved_user1 = await get_solved_challenges(user1['rootme_user_id'])
solved_user1 = sorted(solved_user1, key=lambda x: x['date']) # sort challenge solved by date
solved_user2 = await get_solved_challenges(user2['rootme_user_id'])
solved_user2 = sorted(solved_user2, key=lambda x: x['date']) # sort challenge solved by date
user1_diff, user2_diff = get_diff(solved_user1, solved_user2)
tosend_list = []
tosend = await display_diff_one_side(user1_diff)
tosend_list.append({'user': username1, 'msg': tosend})
tosend = await display_diff_one_side(user2_diff)
tosend_list.append({'user': username2, 'msg': tosend})
return tosend_list
async def display_duration(db: DatabaseManager, context: Context, args: Tuple[str], delay: timedelta) \
-> List[Dict[str, Optional[str]]]:
database_users = await db.select_users(context.guild.id)
if len(args) == 1:
if not await db.user_exists(context.guild.id, args[0]):
tosend = f'User {args[0]} is not in team.'
tosend_list = [{'user': args[0], 'msg': tosend}]
return tosend_list
else:
username = args[0]
users = [db.find_user(database_users, context.guild.id, username)]
else:
users = await db.select_users(context.guild.id)
now = datetime.now()
tosend_list = []
for user in users:
user_info = await Parser.extract_rootme_profile_complete(
user["rootme_user_id"])
if user_info is None: # User {user["rootme_username"]} score is equal to zero
continue
challenges_solved = user_info['validations']
challenges_solved = sorted(challenges_solved,
key=lambda x: x['date'],
reverse=True)
tosend = ''
for challenge in challenges_solved:
date = datetime.strptime(challenge['date'], "%Y-%m-%d %H:%M:%S")
diff = now - date
if diff >= delay:
continue
challenge_info = await Parser.extract_challenge_info(
challenge['id_challenge'])
tosend += f' • {unescape(challenge_info["titre"])} ({challenge_info["score"]} points) - {challenge["date"]}\n'
tosend_list.append({'user': user, 'msg': tosend})
test = [item['msg'] == '' for item in tosend_list]
if len(users) == 1 and False not in test:
tosend = f'No challenges solved by {users[0]["rootme_username"]} :frowning:'
tosend_list = [{'user': None, 'msg': tosend}]
elif False not in test:
tosend = 'No challenges solved by anyone :frowning:'
tosend_list = [{'user': None, 'msg': tosend}]
return tosend_list
async def display_diff_with(db: DatabaseManager, id_discord_server: int, bot: Bot, selected_username: str):
if not await db.user_exists(id_discord_server, selected_username):
tosend = f'User {selected_username} is not in team.'
tosend_list = [{'user': selected_username, 'msg': tosend}]
return tosend_list
tosend_list = []
users = await db.select_users(id_discord_server)
selected_user = db.find_user(users, id_discord_server, selected_username)
solved_user_select = await get_solved_challenges(selected_user['rootme_user_id'])
for user in users:
solved_user = await get_solved_challenges(user['rootme_user_id'])
user_diff, user_diff_select = get_diff(solved_user, solved_user_select)
if user_diff:
tosend = await display_diff_one_side(user_diff)
tosend_list.append({'user': user["rootme_username"], 'msg': tosend})
return tosend_list
""" """
await disp.reset_database(db, context)
def start(self):
if token == 'token':
red('Please update your token in ./bot/constants.py')
sys.exit(0)
self.catch()
self.bot.loop.create_task(self.cron())
self.bot.run(token)
def init_rootme_challenges():
rootme_challenges = {}
for lang in LANGS:
loop = asyncio.get_event_loop() # event loop
future = asyncio.ensure_future(get_categories(lang)) # tasks to do
challenges = loop.run_until_complete(future) # loop until done
rootme_challenges[lang] = challenges
return rootme_challenges
if __name__ == "__main__":
rootme_challenges = init_rootme_challenges()
if rootme_challenges is None:
red('Cannot fetch RootMe challenges from the API.')
sys.exit(0)
db = DatabaseManager(FILENAME, rootme_challenges)
bot = RootMeBot(db)
bot.start()