async def leaderboard(self, ctx):
"""Prints a leaderboard of everyone in the server's battling record
EXAMPLE: !leaderboard
RESULT: A leaderboard of this server's battle records"""
query = """
SELECT
id, battle_rating
FROM
users
WHERE
id = any($1::bigint[])
ORDER BY
battle_rating DESC
"""
results = await ctx.bot.db.fetch(query,
[m.id for m in ctx.guild.members])
if results is None or len(results) == 0:
await ctx.send("No one has battled on this server!")
else:
output = []
for row in results:
member = ctx.guild.get_member(row['id'])
output.append(
f"{member.display_name} (Rating: {row['battle_rating']})")
try:
pages = utils.Pages(ctx, entries=output)
await pages.paginate()
except utils.CannotPaginate as e:
await ctx.send(str(e))
async def restrictions(self, ctx):
"""Used to list all the current restrictions set
EXAMPLE: !restrictions
RESULT: All the current restrictions"""
restrictions = await ctx.bot.db.fetch(
"SELECT source, destination, from_to FROM restrictions WHERE guild=$1",
ctx.guild.id)
entries = []
for restriction in restrictions:
# Check whether it's from or to to change what the format looks like
dest = restriction["destination"]
if dest != "everyone":
dest = await utils.convert(ctx, restriction["destination"])
# If it doesn't exist, don't add it
if dest:
entries.append(
f"{restriction['source']} {'from' if restriction['from_to'] == 'from' else 'to'} {dest}"
)
if entries:
# Then paginate
try:
pages = utils.Pages(ctx, entries=entries)
await pages.paginate()
except utils.CannotPaginate as e:
await ctx.send(str(e))
else:
await ctx.send("There are no restrictions!")
async def urban(self, ctx, *, msg: str):
"""Pulls the top urbandictionary.com definition for a term
EXAMPLE: !urban a normal phrase
RESULT: Probably something lewd; this is urban dictionary we're talking about"""
if utils.channel_is_nsfw(ctx.message.channel):
url = "http://api.urbandictionary.com/v0/define"
params = {"term": msg}
try:
data = await utils.request(url, payload=params)
if data is None:
await ctx.send("Sorry but I failed to connect to urban dictionary!")
return
# List is the list of definitions found, if it's empty then nothing was found
if len(data['list']) == 0:
await ctx.send("No result with that term!")
# If the list is not empty, use the first result and print it's defintion
else:
entries = [x['definition'] for x in data['list']]
try:
pages = utils.Pages(ctx, entries=entries[:5], per_page=1)
await pages.paginate()
except utils.CannotPaginate as e:
await ctx.send(str(e))
# Urban dictionary has some long definitions, some might not be able to be sent
except discord.HTTPException:
await ctx.send('```\nError: Definition is too long for me to send```')
except KeyError:
await ctx.send("Sorry but I failed to connect to urban dictionary!")
else:
await ctx.send("This command is limited to nsfw channels")
async def _handle_show_custom_hugs(self, ctx, opt):
result = await ctx.bot.db.fetchrow(
"SELECT custom_hugs FROM guilds WHERE id = $1", ctx.guild.id)
if result and result["custom_hugs"]:
try:
pages = utils.Pages(ctx, entries=result["custom_hugs"])
await pages.paginate()
except utils.CannotPaginate as e:
await ctx.send(str(e))
else:
return "This server has no custom hugs"
async def role(self, ctx, *, role: discord.Role = None):
"""This command can be used to modify the roles on the server.
Pass no subcommands and this will print the roles currently available on this server
If you give a role as the argument then it will give some information about that role
EXAMPLE: !role
RESULT: A list of all your roles"""
if role:
# Create the embed object
opts = {
"title": role.name,
"colour": role.colour,
}
if role.managed:
opts[
"description"] = "This role is managed by a third party service"
embed = discord.Embed(**opts)
# Add details to it
embed.add_field(name="Created", value=role.created_at.date())
embed.add_field(name="Mentionable",
value="Yes" if role.mentionable else "No")
total_members = len(role.members)
embed.add_field(name="Total members", value=str(total_members))
# If there are only a few members in this role, display them
if 5 >= total_members > 0:
embed.add_field(
name="Members",
value="\n".join(m.display_name for m in role.members),
)
await ctx.send(embed=embed)
else:
# Don't include the colour roles
colour_role = re.compile("Bonfire #.+")
# Simply get a list of all roles in this server and send them
entries = [
r.name for r in ctx.guild.roles[1:]
if not colour_role.match(r.name)
]
if len(entries) == 0:
await ctx.send(
"You do not have any roles setup on this server, other than the default role!"
)
return
try:
pages = utils.Pages(ctx, entries=entries)
await pages.paginate()
except utils.CannotPaginate as e:
await ctx.send(str(e))
async def _handle_show_followed_picarto_channels(self, ctx, opt):
result = await ctx.bot.db.fetchrow(
"SELECT followed_picarto_channels FROM guilds WHERE id = $1",
ctx.guild.id)
if result and result["followed_picarto_channels"]:
try:
pages = utils.Pages(
ctx, entries=result["followed_picarto_channels"])
await pages.paginate()
except utils.CannotPaginate as e:
await ctx.send(str(e))
else:
return "This server is not following any picarto channels"
async def tags(self, ctx):
"""Prints all the custom tags that this server currently has
EXAMPLE: !tags
RESULT: All tags setup on this server"""
tags = await ctx.bot.db.fetch(
"SELECT trigger FROM tags WHERE guild=$1", ctx.guild.id
)
if len(tags) > 0:
entries = [t["trigger"] for t in tags]
pages = utils.Pages(ctx, entries=entries)
await pages.paginate()
else:
await ctx.send("There are no tags setup on this server!")
async def _handle_show_assignable_roles(self, ctx, opt):
result = await ctx.bot.db.fetchrow(
"SELECT assignable_roles FROM guilds WHERE id = $1", ctx.guild.id)
if result and result["assignable_roles"]:
try:
entries = [
ctx.guild.get_role(r).name
for r in result["assignable_roles"]
if ctx.guild.get_role(r) is not None
]
pages = utils.Pages(ctx, entries=entries)
await pages.paginate()
except utils.CannotPaginate as e:
await ctx.send(str(e))
else:
return "This server has no assignable roles"
async def _handle_show_ignored_members(self, ctx, opt):
result = await ctx.bot.db.fetchrow(
"SELECT ignored_members FROM guilds WHERE id = $1", ctx.guild.id)
if result and result["ignored_members"]:
try:
entries = [
ctx.guild.get_member(m).display_name
for m in result["ignored_members"]
if ctx.guild.get_member(m) is not None
]
pages = utils.Pages(ctx, entries=entries)
await pages.paginate()
except utils.CannotPaginate as e:
await ctx.send(str(e))
else:
return "This server is not ignoring any members"
async def mytags(self, ctx):
"""Prints all the custom tags that this server that you own
EXAMPLE: !mytags
RESULT: All your tags setup on this server"""
tags = await ctx.bot.db.fetch(
"SELECT trigger FROM tags WHERE guild=$1 AND creator=$2",
ctx.guild.id,
ctx.author.id,
)
if len(tags) > 0:
entries = [t["trigger"] for t in tags]
pages = utils.Pages(ctx, entries=entries)
await pages.paginate()
else:
await ctx.send("You have no tags on this server!")
async def birthday(self, ctx, *, member: discord.Member = None):
"""A command used to view the birthdays on this server; or a specific member's birthday
EXAMPLE: !birthdays
RESULT: A printout of the birthdays from everyone on this server"""
if member:
date = await ctx.bot.db.fetchrow(
"SELECT birthday FROM users WHERE id=$1", member.id)
if date is None or date["birthday"] is None:
await ctx.send(
f"I do not have {member.display_name}'s birthday saved!")
else:
date = date['birthday']
await ctx.send(
f"{member.display_name}'s birthday is {calendar.month_name[date.month]} {date.day}"
)
else:
# Get this server's birthdays
bds = await self.get_birthdays_for_server(ctx.guild)
# Create entries based on the user's display name and their birthday
entries = [
f"{ctx.guild.get_member(bd['id']).display_name} ({bd['birthday'].strftime('%B %-d')})"
for bd in bds if bd['birthday']
]
if not entries:
await ctx.send("I don't know anyone's birthday in this server!"
)
return
# Create our pages object
try:
pages = utils.Pages(ctx, entries=entries, per_page=5)
pages.title = f"Birthdays for {ctx.guild.name}"
await pages.paginate()
except utils.CannotPaginate as e:
await ctx.send(str(e))
