async def leaderboard(message):
server = Server.get(Server.sid == message.server.id)
leaders = LocalLevel.select().where(
LocalLevel.server == server
).order_by(
LocalLevel.level.desc(), LocalLevel.experience.desc()
).limit(10)
lines = []
lines.append(
f"{'Username'.ljust(32)}{'Level'.ljust(8)}{'XP'.ljust(10)}"
)
for l in leaders:
m = message.server.get_member(f"{l.user.uid}")
req = ((8 * l.level) + await diff(l.level)) * await mxp(l.level)
expstr = f"{l.experience}/{req}"
if m is not None:
username = _removeNonAscii(m.name)
else:
username = "******"
lines.append(
f"{username.ljust(32)}{str(l.level).ljust(8)}{expstr.ljust(10)}"
)
msg = '\n'.join(lines)
codeblock = f"```{msg}```"
await client.send_message(message.channel, codeblock)
def update_server(components=None,
name=None,
vendor=None,
comments=None,
specification_url=None,
availability=None):
server = Server.get(lambda s: s.name == name)
if name is None:
raise Exception('Server name is not specified')
if vendor is not None:
server.vendor = vendor
if comments is not None:
server.comments = comments
if specification_url is not None:
server.specification_url = \
specification_url
if availability is not None:
server.availability = availability
if components is not None:
cmp = select(c for c in Component if c.name in components)[:]
for c in cmp:
server.components.add(c)
c.servers.add(server)
return server
def add_certification(server=None,
fuel_version=None,
date=datetime.now(),
comments=None):
with db_session:
if fuel_version is None:
raise Exception('Fuel version is not specified')
else:
fuel_version = FuelVersion.get(lambda fv: fuel_version == fv.name)
if server is None:
raise Exception('Specify server name')
server = Server.get(lambda s: s.name == server)
if server is None:
raise Exception('No such server in database')
certification = Certification(server=server,
fuel_version=fuel_version,
date=date)
if comments is not None:
certification.comments = comments
# establishing connection between server and certification
certification.server = server
server.certifications.add(certification)
return certification
def make_task(server_id, status):
sleep(10)
db.connect()
try:
server = Server.get(Server.server_id == server_id)
except Server.DoesNotExist:
db.close()
return False
server.status = status
server.save()
db.close()
return True
def delete(self, tenant_id, server_id):
try:
server = Server.get(Server.tenant_id == tenant_id, Server.server_id == server_id)
except Server.DoesNotExist:
self.write({'status': 'not_found'})
return
server.delete_instance()
self.write({
'id': int(server_id),
'status': 'deleted',
})
def get(self, tenant_id, server_id):
try:
server = Server.get(Server.tenant_id == tenant_id, Server.server_id == server_id)
except Server.DoesNotExist:
self.write({'status': 'not_found'})
return
self.write({
'id': server.server_id,
'name': server.name,
'status': server.status,
'date_created': str(server.date_created),
})
def update_followed_list(bot, update, is_follow=True, *_, **kwargs):
try:
server_obj_id = get_server(is_follow=is_follow, **kwargs)
with db_session:
server_obj = Server.get(id=server_obj_id)
# save user
user_name = update.message.from_user.first_name
user_id = update.message.from_user.id
now = datetime.datetime.now()
user = User.get(chat_id=user_id)
if user is None:
user = User(
name=user_name,
chat_id=user_id,
active=False,
created=now,
last_msg=now,
)
if is_follow:
user.servers.add(server_obj)
else:
if is_follow:
user.servers.add(server_obj)
else:
user.servers.remove(server_obj)
commit()
# user_servers_str = ', '.join([s.alias for s in user.servers]) if user is not None else ''
cmd = 'will' if is_follow else 'will not'
# send message
msg = f'you {cmd} receive messages about {server_obj.alias} server status'
try:
bot.send_message(chat_id=update.message.chat_id, text=msg)
except (BadRequest, Unauthorized):
traceback.print_exc()
# send status message
# msg = f'you do\'t follow any servers' if user_servers_str == '' else f'now you follow to: {user_servers_str}'
# bot.send_message(chat_id=update.message.chat_id, text=msg)
except ValidationError as e:
try:
bot.send_message(chat_id=update.message.chat_id, text=str(e))
except (BadRequest, Unauthorized):
traceback.print_exc()
except Exception:
traceback.print_exc()
async def profile(message):
server = Server.get(Server.sid == message.server.id)
user = User.get(User.uid == message.author.id)
lvl = LocalLevel.get((LocalLevel.user == user)
& (LocalLevel.server == server))
req = ((8 * lvl.level) + await diff(lvl.level)) * await mxp(lvl.level)
experience = f"{lvl.experience}/{req}"
lines = [
f"{'Level'.ljust(8)}{'Experience'.ljust(10)}",
f"{str(lvl.level).ljust(8)}{experience.ljust(10)}"
]
msg = '\n'.join(lines)
await client.send_message(message.channel, f"```{msg}```")
async def add_role(message):
# Adds an assignable role
splitmsg = message.content.split()
rolename = ' '.join(splitmsg[1:])
role = discord.utils.get(message.server.roles, name=rolename)
server = Server.get(Server.sid == message.server.id)
r, created = Role.get_or_create(rid=role.id,
defaults={
'assignable': True,
'server': server
})
if not created:
r.assignable = True
r.save()
await reply(f"The {rolename} role is now assignable", message)
async def add_leader_role(message):
# Adds a leaderboard role
splitmsg = message.content.split()
rolename = ' '.join(splitmsg[1:])
role = discord.utils.get(message.server.roles, name=rolename)
server = Server.get(Server.sid == message.server.id)
r, created = Role.get_or_create(rid=role.id,
defaults={
'awardlevel': None,
'leaderboard': True,
'server': server
})
if not created:
r.leaderboard = True
r.save()
await reply(
f"The {rolename} role will now be given when a user enters"
" the leaderboard", message)
async def add_reward(message):
# Adds an reward role
splitmsg = message.content.split()
rolename = ' '.join(splitmsg[1:-1])
level = splitmsg[-1]
role = discord.utils.get(message.server.roles, name=rolename)
server = Server.get(Server.sid == message.server.id)
r, created = Role.get_or_create(rid=role.id,
defaults={
'awardlevel': level,
'server': server
})
if not created:
r.awardlevel = level
r.save()
await reply(
f"The {rolename} role will now be given when a user"
f" hits level {level}", message)
def echo_server_status(bot, server: dict, status: bool):
_alias = server['alias']
status_word = 'up' if status else 'down'
text = f'{_alias} is {status_word} right now'
# send to dev chat
# if _alias == 'dev':
# try:
# bot.send_message(chat_id=DEV_CHAT_ID, text=text)
# except (BadRequest, Unauthorized):
# traceback.print_exc()
# send to followers
with db_session:
for user in Server.get(alias=_alias).users:
print(f'send to {user.name}: {text}')
try:
bot.send_message(chat_id=user.chat_id, text=text)
except (BadRequest, Unauthorized):
traceback.print_exc()
def get_server(is_follow=True, **kwargs):
# get alias
server_alias = kwargs['args'][0] if 'args' in kwargs and len(
kwargs['args']) > 0 else None
if not server_alias:
cmd = 'follow' if is_follow else 'forget'
with db_session:
aliases = [s.alias for s in Server.select()]
msg = f'correct syntax is "/{cmd} {{server_alias}}"\n' \
f'where server_alias is one of {aliases}'
raise ValidationError(msg)
# validate alias
with db_session:
server_obj = Server.get(alias=server_alias)
if server_obj is None:
# noinspection PyTypeChecker
server_aliases = [obj.alias for obj in select(s for s in Server)]
msg = 'choice server_alias from: {}'.format(
', '.join(server_aliases))
raise ValidationError(msg)
return server_obj.id
async def announce_channel(message):
server = Server.get(Server.sid == message.server.id)
server.announce_channel = message.channel.id
await reply(f"I will now do server level up announcements here.", message)
def _load_server(self):
"""
Load the server from the database
:return: None
"""
self.server = Server.get(name=self.config.server_name)
continue
if is_server_alive != server['prev_state']:
echo_server_status(bot, server, is_server_alive)
server['prev_state'] = is_server_alive
except Exception:
with open('/tmp/bot.log', 'w') as file:
traceback.print_exc(file=file)
if __name__ == '__main__':
print('main: init db')
# init db
with db_session:
for alias, url in DEFAULT_SERVERS.items():
obj = Server.get(alias=alias)
if obj is None:
Server(alias=alias, url=url)
commit()
print('main: init bot')
# init bot
updater = Updater(token=TOKEN)
j = updater.job_queue
dispatcher = updater.dispatcher
print('main: regular send messages')
# regular send messages to channel dev_idwell_ru
j.run_repeating(callback_minute, TIMEOUT, first=0.0, context=None, name='test')
print('main: define commands')
