async def show_polls(self, ctx, *, title=None):
async def query_getter(user):
query = Poll.join('users', 'polls.creator_id', '=', 'users.id') \
.where('users.guild_id', user.guild.id)
if title:
query = query.where('polls.title', 'like', f'%{title}%')
if not ut.is_admin(user):
query = query.where('users.id', user.id)
return query
if title:
desc = f"Showing results for '{title}' "
if ut.is_admin(ctx.author):
desc += " in all polls"
else:
desc += " in your polls"
else:
desc = ("Showing all polls" if ut.is_admin(ctx.author) else
"Showing all of your polls")
result = await self.display_poll_search(query_getter,
ctx.author,
ctx.channel,
desc=desc)
if result:
await ctx.message.delete()
def delete(self, transaction_id):
'''
Endpoint for deleting a transaction
Deletes the given Transaction and updates the associated User record's
balance
'''
parser = reqparse.RequestParser()
parser.add_argument('Credits-Token',
location='headers',
required=True,
type=netid_from_token,
dest='admin_netid')
args = parser.parse_args()
# Require an admin session token to delete transactions
if not is_admin(args.admin_netid):
return send_error("Must be admin to delete transaction", 403)
transaction = Transaction.query.filter_by(id=transaction_id).first()
if transaction:
transaction.user.balance -= transaction.amount
db.session.add(transaction.user)
db.session.delete(transaction)
db.session.commit()
return send_success("Deleted transaction: %s" % transaction_id)
else:
return send_error("Unknown transaction")
async def del_poll(self, message):
args = message.content.split()[1:]
poll_id = await self.get_poll_index(message, args)
if poll_id is not None:
poll = self.polls[poll_id]
if poll.dead:
await self.send_message(message.channel,
"I have already deleted that poll.")
return False
if not (poll.author == message.author or is_admin(message.author)):
await self.send_message(message.channel,
"That's not your poll :exclamation:")
return False
await self.edit_message(
poll.poll_message, poll.poll_message.content +
"\n[This poll's results were deleted and you can no longer vote officially in it.]"
)
del self.polls_by_msgid[poll.poll_message.id]
poll.kill()
await self.send_message(message.channel,
"I took care of that poll. :bread:")
while self.polls and self.polls[-1].dead:
self.polls.pop()
self.polls_changed = True
return True
def recover_from_dmd(self, path, tmp_path, when=None):
'''Perform a dar_manager recovery'''
if isinstance(path, list):
path = " ".join(path)
args = {'dar_manager': self.cf.dar_manager_bin, 'dmd_file': self.dmd,
'path': path, 'tmp_path': tmp_path}
tpl = "%(dar_manager)s -B %(dmd_file)s "
tpl += ' -e "-Q -w -R %(tmp_path)s '
if self.cf.encryption:
command_file = mk_dar_crypt_file(self.cf.encryption)
self.logger.debug('Creating encryption command file %s' %
command_file)
tpl += '-B %s ' % command_file
if not is_admin():
tpl += ' --comparison-field=ignore-owner '
#Close the -e quote.
tpl += ' " '
if when:
tpl += "-w %(when)s "
args['when'] = when
tpl += "-Q -r %(path)s "
self.logger.debug(tpl)
rval = self.run_command(tpl, args)
if self.cf.encryption and os.path.exists(command_file):
self.logger.debug('Deleting encryption command file %s' %
command_file)
os.unlink(command_file)
return rval
def customcmd(cog, server_id):
is_admin = utils.is_admin(server_id)
owner = utils.session["user"]["id"]
customcmd_content = db.hgetall("{}:Customcmd:content".format(server_id))
customcmd_brief = db.hgetall("{}:Customcmd:brief".format(server_id))
customcmd_owner = db.hgetall("{}:Customcmd:owner".format(server_id))
current_use = db.hget("{}:Customcmd:owner_use".format(server_id),owner) or 0
use = max_use(server_id)
content = {}
brief = {}
if customcmd_content:
customcmd_content = dict([x,str(y.encode()).replace("\\\\","\\")] for x,y in customcmd_content.items()) #a way to fix escape term. terrible yeh
if is_admin: #if someone is admin, they can view all
log.info("It is admin person")
member = db.hgetall("Info:Name")
content = customcmd_content
brief = customcmd_brief
owner = {}
for name,_id in customcmd_owner.items():
owner[name] = member.get(_id,"UNKNOWN") #getting member name WHILE checking left member
else:
log.info("Not admin person")
for cmd in customcmd_content:#running check each commands to filter out to owner only
if customcmd_owner[cmd] == owner:
content[cmd] = customcmd_content[cmd]
brief[cmd] = customcmd_brief[cmd]
owner = "none"
return render_template("customcmd.html", data_customcmd=content,data_brief = brief,
server_id=server_id,max_use = use,current = current_use,cmd_owner = owner, cog = "customcmd")
def GET(self, targetuid, key):
uid = check_headers()
if utils.is_admin(uid):
utils.delete_user_attribute(targetuid, key)
return result_ok()
else:
return result_nok()
def config():
if not is_admin():
return redirect(url_for("bp_main.home"))
pcfg = {"title": "Application Config"}
_config = Config.query.one()
if not _config:
flash("Config not found", "error")
return redirect(url_for("bp_main.home"))
form = ConfigForm(request.form, obj=_config)
if form.validate_on_submit():
_config.clublog_api_key = form.clublog_api_key.data
_config.eqsl_download_url = form.eqsl_download_url.data
_config.eqsl_rcvd_mark = form.eqsl_rcvd_mark.data
_config.eqsl_upload_url = form.eqsl_upload_url.data
_config.lotw_download_url = form.lotw_download_url.data
_config.lotw_upload_url = form.lotw_upload_url.data
_config.lotw_login_url = form.lotw_login_url.data
_config.lotw_rcvd_mark = form.lotw_rcvd_mark.data
db.session.commit()
flash("Configuration updated", "info")
return redirect(url_for("bp_admin.config"))
return render_template("admin/config.jinja2", pcfg=pcfg, form=form)
def wrapper(update, context):
if not is_admin(update.effective_message.reply_to_message.from_user.id,
update.effective_chat.id, context.bot):
return func(update, context)
update.effective_message.reply_text(
strings.get(strings.cannot_perform_on_admin,
update.effective_chat))
def customcmd(cog, server_id):
is_admin = utils.is_admin(server_id)
owner = utils.session["user"]["id"]
customcmd_content = db.hgetall("{}:Customcmd:content".format(server_id))
customcmd_brief = db.hgetall("{}:Customcmd:brief".format(server_id))
customcmd_owner = db.hgetall("{}:Customcmd:owner".format(server_id))
current_use = db.hget("{}:Customcmd:owner_use".format(server_id),owner) or 0
use = max_use(server_id)
content = {}
brief = {}
if customcmd_content:
customcmd_content = dict([x,str(y.encode()).replace("\\\\","\\")] for x,y in customcmd_content.items()) #a way to fix escape term. terrible yeh
if is_admin or utils.is_owner(): #if someone is admin, they can view all
log.info("It is admin person")
member = db.hgetall("Info:Name")
content = customcmd_content
brief = customcmd_brief
owner = {}
for name,_id in customcmd_owner.items():
owner[name] = member.get(_id,"UNKNOWN") #getting member name WHILE checking left member
else:
log.info("Not admin person")
for cmd in customcmd_content:#running check each commands to filter out to owner only
if customcmd_owner[cmd] == owner:
content[cmd] = customcmd_content[cmd]
brief[cmd] = customcmd_brief[cmd]
owner = "none"
return render_template("customcmd.html", data_customcmd=content,data_brief = brief,
server_id=server_id,max_use = use,current = current_use,cmd_owner = owner, cog = "customcmd")
def predicate(ctx):
if not ctx.guild:
return True
if utils.is_admin(ctx):
return True
else:
raise NoUserPermissionError
def list_log():
if not is_admin(request):
abort(403)
logdir = request.form.get("logdir")
if logdir:
logdir = admin_list_log(logdir)
return str(logdir)
return ''
def view_log():
if not is_admin(request):
abort(403)
logfile = request.form.get("logfile")
if logfile:
logcontent = admin_view_log(logfile)
return logcontent
return ''
async def check_for_duplicate_by_name(ctx, template):
dup = sql.template_get_by_name(ctx.guild.id, template.name)
if dup:
if template.owner_id != ctx.author.id and not utils.is_admin(ctx):
await ctx.send(ctx.s("template.err.name_exists"))
return False
print(dup.x)
q = ctx.s("template.name_exists_ask_replace") \
.format(dup.name, canvases.pretty_print[dup.canvas], dup.x, dup.y)
return await utils.yes_no(ctx, q)
def post(self):
self.response.headers['Content-Type'] = 'application/json'
try:
int(self.request.get('user_id'))
except:
self.response.write(json.dumps({"status": "NOT OK", "message": "Valid user_id must be supplied."}))
return
room_exists = True
roomlist_name = self.request.get('roomlist_name',utils.DEFAULT_ROOMLIST_NAME)
room_id = self.request.get('room_id')
if not room_id:
room_exists = False
else:
try:
room = models.Room.get_by_id(int(room_id),parent=utils.roomlist_key(roomlist_name))
if room == None:
room_exists = False
except:
room_exists = False
if room_exists:
if not utils.is_admin(room,self.request.get('user_id')):
self.response.write(json.dumps({"status": "NOT OK", "message": "You must be an admin to reorder songs."}))
return
if not room_exists:
self.response.write(json.dumps({"status": "NOT OK", "message": "The requested room was not found."}))
else:
if room.mode != 0:
self.response.write(json.dumps({"status": "NOT OK", "message": "You can only reorder songs in First Come First Serve mode."}))
else:
allowed = utils.checkPassword(self.request.get('password', ''), room.password)
if not allowed:
self.response.write(json.dumps({"status": "NOT OK", "message": "The correct password was not provided."}))
else:
#TODO: Error checking
song_exists = True
try:
song_id = int(self.request.get('song_id'))
except:
song_exists = False
if not song_exists or room.queue.count(song_id) == 0:
self.response.write(json.dumps({"status": "NOT OK", "message": "The requested song is not in the Room's queue."}))
else:
try:
new_pos = int(self.request.get('new_pos'))
except: # originally a else, getting a syntax error
new_pos = 0
room.queue.remove(song_id)
room.queue.insert(new_pos,song_id)
room.put()
self.response.write(json.dumps({"status":"OK"}))
async def template_remove(self, ctx, name):
t = sql.template_get_by_name(ctx.guild.id, name)
if not t:
raise TemplateNotFoundError
log.info("(T:{})".format(t.name, t.gid))
if t.owner_id != ctx.author.id and not utils.is_template_admin(
ctx) and not utils.is_admin(ctx):
await ctx.send(ctx.s("template.err.not_owner"))
return
sql.template_delete(t.gid, t.name)
await ctx.send(ctx.s("template.remove").format(name))
async def template_remove(self, ctx, name):
t = ctx.session.query(TemplateDb).filter_by(guild_id=ctx.guild.id,
name=name).first()
if not t:
raise TemplateNotFoundError(ctx, ctx.guild.id, name)
if t.owner != ctx.author.id and not utils.is_template_admin(
ctx) and not utils.is_admin(ctx):
await ctx.send(ctx.s("template.err.not_owner"))
return
ctx.session.delete(t)
await ctx.send(ctx.s("template.remove").format(name))
async def query_getter(user):
query = Poll.join('users', 'polls.creator_id', '=', 'users.id') \
.where('users.guild_id', user.guild.id)
if title:
query = query.where('polls.title', 'like', f'%{title}%')
if not ut.is_admin(user):
query = query.where('users.id', user.id)
return query
def logs_delete(log_id):
if not is_admin():
_datas = {"status": "error", "id": log_id}
else:
log = Logging.query.filter(Logging.id == log_id).first()
if not log:
_datas = {"status": "error", "id": log_id}
else:
db.session.delete(log)
db.session.commit()
_datas = {"status": "deleted", "id": log_id}
return Response(json.dumps(_datas), mimetype="application/json;charset=utf-8")
async def snapshot_remove(self, ctx, base_template, snapshot_template):
if not utils.is_template_admin(ctx) and not utils.is_admin(ctx):
return await ctx.send(ctx.s("template.err.not_owner"))
snap = ctx.session.query(Snapshot).filter(
Snapshot.base_template.has(name=base_template),
Snapshot.target_template.has(name=snapshot_template)).first()
if not snap:
return await ctx.send("That snapshot does not exist.")
ctx.session.delete(snap)
await ctx.send("Snapshot removed!")
async def template_snapshot_remove(self, ctx, base_template,
snapshot_template):
if not utils.is_template_admin(ctx) and not utils.is_admin(ctx):
await ctx.send(ctx.s("template.err.not_owner"))
return
s = sql.snapshot_get_by_names(ctx.guild.id, base_template,
snapshot_template)
if s is None:
await ctx.send("That snapshot does not exist.")
return
sql.snapshot_delete(ctx.guild.id, base_template, snapshot_template)
await ctx.send("Snapshot removed!")
def get_logs_handler(update, context):
chat = utils.get_chat(context, update)
chat_id = chat.effective_chat.id
bot = utils.get_bot(context, update)
logger.info(f'get_logs_handler -> {chat_id}')
if utils.is_admin(chat_id):
try:
f = open('deliver_bot.log', 'rb')
bot.send_document(
chat_id=chat_id,
document=f
)
except Exception as ex:
logger.warning(f'{ex}')
async def user_end_poll(self, poll, message, user: discord.User):
# Only the creator of the poll can end the poll
if poll.creator_id != user.id and not ut.is_admin(user):
return
result, reason = await ut.get_confirmation(
message.channel, user, self.bot,
"Are you sure you want to end the poll now?")
# Brings forward the end date for the poll to current time
#
# The poll will end the poll on its next iteration
if result:
poll.end_date = ut.get_utc_time()
poll.save()
def get_db_handler(update, context):
chat = utils.get_chat(context, update)
chat_id = chat.effective_chat.id
bot = utils.get_bot(context, update)
logger.info(f'get_db_handler -> {chat_id}')
if utils.is_admin(chat_id):
try:
f_path = os.path.join(os.path.dirname(__file__), 'admin/db.sqlite')
f = open(f_path, 'rb')
bot.send_document(
chat_id=chat_id,
document=f
)
except Exception:
pass
async def reread_votes(self, message):
args = message.content.split()[1:]
poll_id = await self.get_poll_index(message, args)
if poll_id is not None:
poll = self.polls[poll_id]
if not (poll.author == message.author or is_admin(message.author)):
await self.send_message(message.channel,
"That's not your poll :exclamation:")
return False
for v in poll.votes:
v.clear()
for reaction in poll.poll_message.reactions:
user_list = await self.get_reaction_users(reaction, limit=100)
for user in user_list:
await handle_reaction_addition(self, reaction, user)
await self.send_message(message.channel, "Done rereading :)")
return True
async def user_delete_poll(self, poll, message, user: discord.User):
# Only the creator of the poll or admins can delete it
if poll.creator_id != user.id and not ut.is_admin(user):
return
# Awaits confirmation of the deletion
result, reason = await ut.get_confirmation(
message.channel, user, self.bot,
"Are you sure you want to delete the poll? "
"The poll will be deleted from the conversation.\n"
"You can use the `summonpoll` command to bring the poll back")
if result:
# The message containing the poll is deleted
await message.delete()
return result
def get_report_handler(update, context):
chat = utils.get_chat(context, update)
chat_id = chat.effective_chat.id
bot = utils.get_bot(context, update)
logger.info(f'get_report_handler -> {chat_id}')
db.export_orders_to_file()
if utils.is_admin(chat_id):
try:
f = open('orders.csv', 'rb')
bot.send_document(
chat_id=chat_id,
document=f
)
except Exception as ex:
logger.warning(f'{ex}')
pass
async def snapshot_add(self, ctx, base_template, snapshot_template):
if not utils.is_template_admin(ctx) and not utils.is_admin(ctx):
await ctx.send(ctx.s("template.err.not_owner"))
return
base = ctx.session.query(TemplateDb).filter_by(
guild_id=ctx.guild.id, name=base_template).first()
target = ctx.session.query(TemplateDb).filter_by(
guild_id=ctx.guild.id, name=snapshot_template).first()
if base is None:
return await ctx.send("The base template does not exist.")
if target is None:
return await ctx.send("The snapshot template does not exist.")
snap = Snapshot(base_template=base, target_template=target)
ctx.session.add(snap)
await ctx.send("Snapshot added!")
async def template_snapshot_add(self, ctx, base_template,
snapshot_template):
if not utils.is_template_admin(ctx) and not utils.is_admin(ctx):
await ctx.send(ctx.s("template.err.not_owner"))
return
base = sql.template_get_by_name(ctx.guild.id, base_template)
target = sql.template_get_by_name(ctx.guild.id, snapshot_template)
if base == None:
await ctx.send("The base template does not exist.")
return
if target == None:
await ctx.send("The snapshot template does not exist.")
return
sql.snapshot_add(ctx.guild.id, base_template, snapshot_template)
await ctx.send("Snapshot added!")
def reply_all_handler(update, context):
if utils.is_admin(update.message.chat_id):
logger.info(f'reply_all_handler -> text: {update.message.text}')
users = db.get_all_users()
for user in users:
try:
logger.info(f'reply_all_handler -> {user}')
context.bot.send_message(
chat_id=user.user_id,
text=update.message.text_markdown.replace(
f'/replyall', ''),
parse_mode=ParseMode.MARKDOWN,
disable_web_page_preview=True
)
except Exception as ex:
logger.warning(f'{ex}')
logger.warning(f'reply_all_handler -> {ex}')
pass
async def on_message(self, message):
"""
don't touch this! keep it abstract
"""
# we don't want interaction in any other channels
if message.channel.id != self.secret_channel.id:
return
# quick content reference
content = message.content
# we also want to skip anything that doesn't start with the prefix
if not content.startswith("!"):
return
# strip prefix
content = content[1:]
# get base command
base_command = content.split(" ")
# the function to call
cmd_funct = None
# parse base commands (not mapped)
if content == 'commands':
await self.commands(message)
elif content == 'rules':
await self.rules(message)
elif content == 'devme':
await self.devme(message)
elif base_command[0] in commands_map:
# user commands
cmd_funct = self._get_command_function(commands_map, base_command)
elif base_command[0] in dev_commands_map and utils.is_dev(message.author):
# dev commands
cmd_funct = self._get_command_function(dev_commands_map, base_command)
elif base_command[0] in admin_commands_map and utils.is_admin(message.author):
# admin commands
cmd_funct = self._get_command_function(admin_commands_map, base_command)
if cmd_funct is not None:
await cmd_funct(message)
async def summon_poll(self, ctx, poll_id: int):
"""
Allows a user to bring forward a poll in the conversation,
for the benefit of longer-duration polls
"""
poll = Poll.find(poll_id)
if not poll:
await ctx.send(f"Poll with ID {poll_id} could not found.")
return
if ctx.author.id != poll.creator_id and not ut.is_admin(ctx.author):
await ctx.send("You don't have permission to summon that poll!")
return
old_channel = self.bot.get_channel(poll.channel_id)
try:
old_message = await old_channel.fetch_message(poll.message_id)
await old_message.delete()
except discord.errors.NotFound:
pass
embed = await self.create_poll_embed(poll.title, poll.end_date,
poll.ended)
new_message = await ctx.send(embed=embed)
if not poll.ended:
await new_message.add_reaction(ADD_CHOICE_EMOJI)
await new_message.add_reaction(DELETE_POLL_EMOJI)
if not poll.ended:
await new_message.add_reaction(END_POLL_EMOJI)
for choice in poll.choices:
await new_message.add_reaction(choice.reaction)
await ctx.message.delete()
poll.message_id = new_message.id
poll.channel_id = ctx.channel.id
poll.save()
await self.update_response_counts(poll)
async def new_account(ctx, user: discord.Member = None):
"""
Create an account for a new account
"""
if user is None:
user_id = ctx.author.id
elif utils.is_admin(ctx):
user_id = user.id
else:
res = "Erreur : vous ne pouvez pas créer un compte pour une autre personne."
log_info(res)
await ctx.send(res)
return
if bank.new_account(user_id):
res = "<@{}> a maintenant un compte en banque.".format(user_id)
else:
res = "Erreur : <@{}> a déjà un compte en banque.".format(user_id)
log_info(res)
await ctx.send(res)
async def stop_poll(self, message):
args = message.content.split()[1:]
poll_id = await self.get_poll_index(message, args)
if poll_id is not None:
poll = self.polls[poll_id]
if not poll.active:
await self.send_message(
message.channel, "I have already deactivated that poll.")
return False
if not (poll.author == message.author or is_admin(message.author)):
await self.send_message(message.channel,
"That's not your poll :exclamation:")
return False
await self.edit_message(
poll.poll_message,
poll.poll_message.content + "\n[This poll has ended.]")
poll.deactivate()
await self.send_message(message.channel,
"I deactivated that poll. :bulb:")
self.polls_changed = True
return True
def config():
if not is_admin():
return redirect(url_for("bp_main.home"))
pcfg = {"title": gettext("Application Config")}
_config = Config.query.one()
if not _config:
flash(gettext("Config not found"), "error")
return redirect(url_for("bp_main.home"))
form = ConfigForm(request.form, obj=_config)
if form.validate_on_submit():
_config.app_name = form.app_name.data
_config.app_description = form.app_description.data
db.session.commit()
flash(gettext("Configuration updated"), "info")
return redirect(url_for("bp_admin.config"))
return render_template("admin/config.jinja2", pcfg=pcfg, form=form)
q = self.sess.query(Catalog)
if not catalog:
last = q.filter(and_(Catalog.clean,
Catalog.job == self.Job,
Catalog.type == self.Full
)).order_by(Catalog.date.desc()).first()
childs = getchilds(last)
else:
try:
last = q.filter_by(id=catalog).one()
childs = getancestors(last)
except NoResultFound, e:
raise RecoverError("% s is not a valid jobid." % catalog)
if not is_admin():
tpl += "-O ignore-owner "
if self.cf.encryption:
command_file = mk_dar_crypt_file(self.cf.encryption)
self.logger.debug('Creating encryption command file %s' %
command_file)
tpl += '-B %s ' % command_file
args = {'dar_bin': self.cf.dar_bin, 'recover_path': rpath}
#If catalog was given, we need to sort the list.
all_archives = sorted([last] + childs, key=lambda x: x.date)
self.logger.debug("Restoring from: %s" % all_archives)
_err = False
for arch in all_archives:
def levels(server_id):
is_admin = utils.is_admin(server_id)
css_theme = "css/custom/{}.css".format(server_id) if os.path.isfile("static/css/custom/{}.css".format(server_id)) else None
print(css_theme)
is_private=False
if db.get("{}:Level:Private".format(server_id)) == "on":
is_private=True
#Check if server and plugins are in
server_check = db.hget("Info:Server",server_id)
if server_check is None:
return redirect(url_for('index'))
plugin_check = db.hget("{}:Config:Cogs".format(server_id),"level")
if plugin_check is None:
return redirect(url_for('index'))
log.info("Pass all requirement check")
server = {
'id':server_id,
'name':server_check,
'icon':db.hget("Info:Server_Icon",server_id)}
#Players' level
name_list = db.hgetall("Info:Name")
avatar_list = db.hgetall("Info:Icon")
total_member = len(db.smembers("{}:Level:Player".format(server_id)))
player_data = db.sort("{}:Level:Player".format(server_id), by="{}:Level:Player:*->Total_XP".format(server_id), get=[
"{}:Level:Player:*->ID".format(server_id),
"{}:Level:Player:*->Total_XP".format(server_id),], start=0, num=total_member, desc=True)
data = []
total_exp = 0
for x in range(0,len(player_data),2):
if name_list.get(player_data[x]) is None:
db.srem("{}:Level:Player".format(server_id),player_data[x])
if player_data[x] is None: continue
# print(player_data[x],player_data[x+1]) #for future references
total_exp += int(player_data[x+1])
level, remain,next_xp= next_Level(int(player_data[x+1]))
name = name_list.get(player_data[x],"None#1234").split("#")
temp = {
"Name":name[0],
"ID":player_data[x],
"Level":level,
"XP": remain,
"Next_XP":next_xp,
"Total_XP":player_data[x+1],
"Discriminator":name[1],
"Avatar":avatar_list.get(player_data[x]),
"XP_Percent":100*(float(remain)/float(next_xp))
}
data.append(temp)
log.info("Done gather player infos")
#Role rewards
get_role = utils.resource_get("/guilds/{}".format(server_id))
guild_roles = get_role['roles']
role_level = db.hgetall("{}:Level:role_reward".format(server_id)) or {}
reward_roles = [
{"name":x['name'],
"id":x['id'],
"color":hex(x["color"]).split("0x")[1],
"level":role_level.get(x["id"],0)} for x in guild_roles if role_level.get(x["id"],"0") != "0" and x["id"] != str(server_id)]
reward_roles.sort(key=lambda x: x['name'])
print(reward_roles)
#Those are for Website
stats = {"total_member":total_member,"total_exp":total_exp}
if request.args.get('json'):
log.info("Requesting Json")
return jsonify({"server:":server,"reward_roles":reward_roles,"players":data})
return render_template('level/levels.html', players=data, stats = stats, reward_roles = reward_roles,server=server, title="{} leaderboard".format(server['name']),is_admin=is_admin,is_private=is_private,css_theme = css_theme)
def GET(self):
if utils.is_admin():
raise web.seeother('/')
return render.admin.login(None)
def GET(self):
uid = check_headers()
if utils.is_admin(uid):
return utils.get_users_with_notifications()
else:
return result_nok()
