CodeMirror/Bonfire
1
0
Fork 0
mirror of synced 2024-05-19 20:12:30 +12:00
Code Issues Releases Wiki Activity

Change to check all requirements in the command checks, not some in on_message

Browse source
This commit is contained in:
phxntxm 2018-09-23 17:34:14 -05:00
parent ad0b4a6362
commit a96835326c
27 changed files with 268 additions and 389 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

11
bot.py
View file

@ -29,21 +29,14 @@ async def on_ready():
bot.owner = appinfo.owner bot.owner = appinfo.owner
@bot.event
async def on_message(message):
if message.author.bot or utils.should_ignore(bot, message):
return
await bot.process_commands(message)
@bot.event @bot.event
async def on_command_completion(ctx): async def on_command_completion(ctx):
author = ctx.message.author author = ctx.message.author
server = ctx.message.guild server = ctx.message.guild
command = ctx.command command = ctx.command
command_usage = await bot.db.actual_load('command_usage', key=command.qualified_name) or \ command_usage = await bot.db.actual_load('command_usage', key=command.qualified_name) \
{'command': command.qualified_name} or {'command': command.qualified_name}
# Add one to the total usage for this command, basing it off 0 to start with (obviously) # Add one to the total usage for this command, basing it off 0 to start with (obviously)
total_usage = command_usage.get('total_usage', 0) + 1 total_usage = command_usage.get('total_usage', 0) + 1

95
cogs/admin.py
View file

@ -15,8 +15,7 @@ class Administration:
@commands.group(invoke_without_command=True) @commands.group(invoke_without_command=True)
@commands.guild_only() @commands.guild_only()
@utils.custom_perms(send_messages=True) @utils.can_run(send_messages=True)
@utils.check_restricted()
async def battles(self, ctx): async def battles(self, ctx):
"""Used to list the server specific battles messages on this server """Used to list the server specific battles messages on this server
@ -34,8 +33,7 @@ class Administration:
@battles.command(name='add') @battles.command(name='add')
@commands.guild_only() @commands.guild_only()
@utils.custom_perms(manage_guild=True) @utils.can_run(manage_guild=True)
@utils.check_restricted()
async def add_battles(self, ctx, *, message): async def add_battles(self, ctx, *, message):
"""Used to add a battle message to the server specific battle messages """Used to add a battle message to the server specific battle messages
Use {winner} or {loser} in order to display the winner/loser's display name Use {winner} or {loser} in order to display the winner/loser's display name
@ -65,8 +63,7 @@ class Administration:
@battles.command(name='remove', aliases=['delete']) @battles.command(name='remove', aliases=['delete'])
@commands.guild_only() @commands.guild_only()
@utils.custom_perms(manage_guild=True) @utils.can_run(manage_guild=True)
@utils.check_restricted()
async def remove_battles(self, ctx): async def remove_battles(self, ctx):
"""Used to remove one of the custom hugs from the server's list of hug messages """Used to remove one of the custom hugs from the server's list of hug messages
@ -113,8 +110,7 @@ class Administration:
@battles.command(name='default') @battles.command(name='default')
@commands.guild_only() @commands.guild_only()
@utils.custom_perms(send_messages=True) @utils.can_run(send_messages=True)
@utils.check_restricted()
async def default_battles(self, ctx): async def default_battles(self, ctx):
"""Used to toggle if battles should include default messages as well as server-custom messages """Used to toggle if battles should include default messages as well as server-custom messages
@ -136,8 +132,7 @@ class Administration:
@commands.group(invoke_without_command=True) @commands.group(invoke_without_command=True)
@commands.guild_only() @commands.guild_only()
@utils.custom_perms(send_messages=True) @utils.can_run(send_messages=True)
@utils.check_restricted()
async def hugs(self, ctx): async def hugs(self, ctx):
"""Used to list the server specific hug messages on this server """Used to list the server specific hug messages on this server
@ -155,8 +150,7 @@ class Administration:
@hugs.command(name='add') @hugs.command(name='add')
@commands.guild_only() @commands.guild_only()
@utils.custom_perms(manage_guild=True) @utils.can_run(manage_guild=True)
@utils.check_restricted()
async def add_hugs(self, ctx, *, message): async def add_hugs(self, ctx, *, message):
"""Used to add a hug to the server specific hug messages """Used to add a hug to the server specific hug messages
Use {user} in order to display the user's display name Use {user} in order to display the user's display name
@ -182,8 +176,7 @@ class Administration:
@hugs.command(name='remove', aliases=['delete']) @hugs.command(name='remove', aliases=['delete'])
@commands.guild_only() @commands.guild_only()
@utils.custom_perms(manage_guild=True) @utils.can_run(manage_guild=True)
@utils.check_restricted()
async def remove_hugs(self, ctx): async def remove_hugs(self, ctx):
"""Used to remove one of the custom hugs from the server's list of hug messages """Used to remove one of the custom hugs from the server's list of hug messages
@ -230,8 +223,7 @@ class Administration:
@hugs.command(name='default') @hugs.command(name='default')
@commands.guild_only() @commands.guild_only()
@utils.custom_perms(send_messages=True) @utils.can_run(send_messages=True)
@utils.check_restricted()
async def default_hugs(self, ctx): async def default_hugs(self, ctx):
"""Used to toggle if hugs should include default messages as well as server-custom messages """Used to toggle if hugs should include default messages as well as server-custom messages
@ -253,8 +245,7 @@ class Administration:
@commands.command() @commands.command()
@commands.guild_only() @commands.guild_only()
@utils.custom_perms(manage_guild=True) @utils.can_run(manage_guild=True)
@utils.check_restricted()
async def allowbirthdays(self, ctx, setting): async def allowbirthdays(self, ctx, setting):
"""Turns on/off the birthday announcements in this server """Turns on/off the birthday announcements in this server
@ -274,8 +265,7 @@ class Administration:
@commands.command() @commands.command()
@commands.guild_only() @commands.guild_only()
@utils.custom_perms(manage_guild=True) @utils.can_run(manage_guild=True)
@utils.check_restricted()
async def allowcolours(self, ctx, setting): async def allowcolours(self, ctx, setting):
"""Turns on/off the ability to use colour roles in this server """Turns on/off the ability to use colour roles in this server
@ -295,8 +285,7 @@ class Administration:
@commands.command() @commands.command()
@commands.guild_only() @commands.guild_only()
@utils.custom_perms(manage_guild=True) @utils.can_run(manage_guild=True)
@utils.check_restricted()
async def allowplaylists(self, ctx, setting): async def allowplaylists(self, ctx, setting):
"""Turns on/off the ability to playlists """Turns on/off the ability to playlists
@ -316,8 +305,7 @@ class Administration:
@commands.command() @commands.command()
@commands.guild_only() @commands.guild_only()
@utils.custom_perms(kick_members=True) @utils.can_run(kick_members=True)
@utils.check_restricted()
async def restrictions(self, ctx): async def restrictions(self, ctx):
"""Used to list all the current restrictions set """Used to list all the current restrictions set
@ -354,8 +342,7 @@ class Administration:
@commands.command() @commands.command()
@commands.guild_only() @commands.guild_only()
@utils.custom_perms(manage_guild=True) @utils.can_run(manage_guild=True)
@utils.check_restricted()
async def restrict(self, ctx, *options): async def restrict(self, ctx, *options):
""" """
This is an intuitive command to restrict something to/from something This is an intuitive command to restrict something to/from something
@ -581,8 +568,7 @@ class Administration:
@commands.command() @commands.command()
@commands.guild_only() @commands.guild_only()
@utils.custom_perms(manage_guild=True) @utils.can_run(manage_guild=True)
@utils.check_restricted()
async def unrestrict(self, ctx, *options): async def unrestrict(self, ctx, *options):
""" """
This is an intuitive command to unrestrict something to/from something This is an intuitive command to unrestrict something to/from something
@ -679,8 +665,7 @@ class Administration:
@commands.command(aliases=['nick']) @commands.command(aliases=['nick'])
@commands.guild_only() @commands.guild_only()
@utils.custom_perms(kick_members=True) @utils.can_run(kick_members=True)
@utils.check_restricted()
async def nickname(self, ctx, *, name=None): async def nickname(self, ctx, *, name=None):
"""Used to set the nickname for Bonfire (provide no nickname and it will reset) """Used to set the nickname for Bonfire (provide no nickname and it will reset)
@ -695,8 +680,7 @@ class Administration:
@commands.command() @commands.command()
@commands.guild_only() @commands.guild_only()
@utils.custom_perms(manage_guild=True) @utils.can_run(manage_guild=True)
@utils.check_restricted()
async def ignore(self, ctx, member_or_channel): async def ignore(self, ctx, member_or_channel):
"""This command can be used to have Bonfire ignore certain members/channels """This command can be used to have Bonfire ignore certain members/channels
@ -747,8 +731,7 @@ class Administration:
@commands.command() @commands.command()
@commands.guild_only() @commands.guild_only()
@utils.custom_perms(manage_guild=True) @utils.can_run(manage_guild=True)
@utils.check_restricted()
async def unignore(self, ctx, member_or_channel): async def unignore(self, ctx, member_or_channel):
"""This command can be used to have Bonfire stop ignoring certain members/channels """This command can be used to have Bonfire stop ignoring certain members/channels
@ -796,8 +779,7 @@ class Administration:
@commands.command(aliases=['notifications']) @commands.command(aliases=['notifications'])
@commands.guild_only() @commands.guild_only()
@utils.custom_perms(manage_guild=True) @utils.can_run(manage_guild=True)
@utils.check_restricted()
async def alerts(self, ctx, channel: discord.TextChannel): async def alerts(self, ctx, channel: discord.TextChannel):
"""This command is used to set a channel as the server's default 'notifications' channel """This command is used to set a channel as the server's default 'notifications' channel
Any notifications (like someone going live on Twitch, or Picarto) will go to that channel by default Any notifications (like someone going live on Twitch, or Picarto) will go to that channel by default
@ -819,8 +801,7 @@ class Administration:
@commands.group(invoke_without_command=True, aliases=['goodbye']) @commands.group(invoke_without_command=True, aliases=['goodbye'])
@commands.guild_only() @commands.guild_only()
@utils.custom_perms(manage_guild=True) @utils.can_run(manage_guild=True)
@utils.check_restricted()
async def welcome(self, ctx, on_off: str): async def welcome(self, ctx, on_off: str):
"""This command can be used to set whether or not you want user notificaitons to show """This command can be used to set whether or not you want user notificaitons to show
Provide on, yes, or true to set it on; otherwise it will be turned off Provide on, yes, or true to set it on; otherwise it will be turned off
@ -843,8 +824,7 @@ class Administration:
@welcome.command(name='alerts', aliases=['notifications']) @welcome.command(name='alerts', aliases=['notifications'])
@commands.guild_only() @commands.guild_only()
@utils.custom_perms(manage_guild=True) @utils.can_run(manage_guild=True)
@utils.check_restricted()
async def _welcome_alerts(self, ctx, *, channel: discord.TextChannel): async def _welcome_alerts(self, ctx, *, channel: discord.TextChannel):
"""A command used to set the override for notifications about users joining/leaving """A command used to set the override for notifications about users joining/leaving
@ -863,8 +843,7 @@ class Administration:
@welcome.command(name='message') @welcome.command(name='message')
@commands.guild_only() @commands.guild_only()
@utils.custom_perms(manage_guild=True) @utils.can_run(manage_guild=True)
@utils.check_restricted()
async def _welcome_message(self, ctx, *, msg): async def _welcome_message(self, ctx, *, msg):
"""A command to customize the welcome/goodbye message """A command to customize the welcome/goodbye message
There are a couple things that can be set to customize the message There are a couple things that can be set to customize the message
@ -894,15 +873,13 @@ class Administration:
await ctx.send("I have just updated your {} message".format(parent)) await ctx.send("I have just updated your {} message".format(parent))
@commands.group() @commands.group()
@utils.check_restricted()
async def nsfw(self, ctx): async def nsfw(self, ctx):
"""Handles adding or removing a channel as a nsfw channel""" """Handles adding or removing a channel as a nsfw channel"""
# This command isn't meant to do anything, so just send an error if an invalid subcommand is passed # This command isn't meant to do anything, so just send an error if an invalid subcommand is passed
pass pass
@nsfw.command(name="add") @nsfw.command(name="add")
@utils.custom_perms(kick_members=True) @utils.can_run(kick_members=True)
@utils.check_restricted()
async def nsfw_add(self, ctx): async def nsfw_add(self, ctx):
"""Registers this channel as a 'nsfw' channel """Registers this channel as a 'nsfw' channel
@ -927,8 +904,7 @@ class Administration:
await ctx.send("This channel has just been registered as 'nsfw'! Have fun you naughties ;)") await ctx.send("This channel has just been registered as 'nsfw'! Have fun you naughties ;)")
@nsfw.command(name="remove", aliases=["delete"]) @nsfw.command(name="remove", aliases=["delete"])
@utils.custom_perms(kick_members=True) @utils.can_run(kick_members=True)
@utils.check_restricted()
async def nsfw_remove(self, ctx): async def nsfw_remove(self, ctx):
"""Removes this channel as a 'nsfw' channel """Removes this channel as a 'nsfw' channel
@ -955,8 +931,7 @@ class Administration:
@commands.group(invoke_without_command=True) @commands.group(invoke_without_command=True)
@commands.guild_only() @commands.guild_only()
@utils.custom_perms(send_messages=True) @utils.can_run(send_messages=True)
@utils.check_restricted()
async def perms(self, ctx, *, command: str = None): async def perms(self, ctx, *, command: str = None):
"""This command can be used to print the current allowed permissions on a specific command """This command can be used to print the current allowed permissions on a specific command
This supports groups as well as subcommands; pass no argument to print a list of available permissions This supports groups as well as subcommands; pass no argument to print a list of available permissions
@ -997,9 +972,9 @@ class Administration:
perms_value = server_perms.get(cmd.qualified_name) perms_value = server_perms.get(cmd.qualified_name)
if perms_value is None: if perms_value is None:
# If we don't find custom permissions, get the required permission for a command # If we don't find custom permissions, get the required permission for a command
# based on what we set in utils.custom_perms, if custom_perms isn't found, we'll get an IndexError # based on what we set in utils.can_run, if can_run isn't found, we'll get an IndexError
try: try:
custom_perms = [func for func in cmd.checks if "custom_perms" in func.__qualname__][0] can_run = [func for func in cmd.checks if "can_run" in func.__qualname__][0]
except IndexError: except IndexError:
# Loop through and check if there is a check called is_owner # Loop through and check if there is a check called is_owner
# If we loop through and don't find one, this means that the only other choice is to be # If we loop through and don't find one, this means that the only other choice is to be
@ -1013,8 +988,8 @@ class Administration:
)) ))
return return
# Perms will be an attribute if custom_perms is found no matter what, so no need to check this # Perms will be an attribute if can_run is found no matter what, so no need to check this
perms = "\n".join(attribute for attribute, setting in custom_perms.perms.items() if setting) perms = "\n".join(attribute for attribute, setting in can_run.perms.items() if setting)
await ctx.send( await ctx.send(
"You are required to have `{}` permissions to run `{}`".format(perms, cmd.qualified_name)) "You are required to have `{}` permissions to run `{}`".format(perms, cmd.qualified_name))
else: else:
@ -1029,7 +1004,6 @@ class Administration:
@perms.command(name="add", aliases=["setup,create"]) @perms.command(name="add", aliases=["setup,create"])
@commands.guild_only() @commands.guild_only()
@commands.has_permissions(manage_guild=True) @commands.has_permissions(manage_guild=True)
@utils.check_restricted()
async def add_perms(self, ctx, *msg: str): async def add_perms(self, ctx, *msg: str):
"""Sets up custom permissions on the provided command """Sets up custom permissions on the provided command
Format must be 'perms add <command> <permission>' Format must be 'perms add <command> <permission>'
@ -1095,7 +1069,6 @@ class Administration:
@perms.command(name="remove", aliases=["delete"]) @perms.command(name="remove", aliases=["delete"])
@commands.guild_only() @commands.guild_only()
@commands.has_permissions(manage_guild=True) @commands.has_permissions(manage_guild=True)
@utils.check_restricted()
async def remove_perms(self, ctx, *, command: str): async def remove_perms(self, ctx, *, command: str):
"""Removes the custom permissions setup on the command specified """Removes the custom permissions setup on the command specified
@ -1119,8 +1092,7 @@ class Administration:
@commands.command() @commands.command()
@commands.guild_only() @commands.guild_only()
@utils.custom_perms(manage_guild=True) @utils.can_run(manage_guild=True)
@utils.check_restricted()
async def prefix(self, ctx, *, prefix: str): async def prefix(self, ctx, *, prefix: str):
"""This command can be used to set a custom prefix per server """This command can be used to set a custom prefix per server
@ -1149,8 +1121,7 @@ class Administration:
@commands.group(aliases=['rule'], invoke_without_command=True) @commands.group(aliases=['rule'], invoke_without_command=True)
@commands.guild_only() @commands.guild_only()
@utils.custom_perms(send_messages=True) @utils.can_run(send_messages=True)
@utils.check_restricted()
async def rules(self, ctx, rule: int = None): async def rules(self, ctx, rule: int = None):
"""This command can be used to view the current rules on the server """This command can be used to view the current rules on the server
@ -1179,8 +1150,7 @@ class Administration:
@rules.command(name='add', aliases=['create']) @rules.command(name='add', aliases=['create'])
@commands.guild_only() @commands.guild_only()
@utils.custom_perms(manage_guild=True) @utils.can_run(manage_guild=True)
@utils.check_restricted()
async def rules_add(self, ctx, *, rule: str): async def rules_add(self, ctx, *, rule: str):
"""Adds a rule to this server's rules """Adds a rule to this server's rules
@ -1201,8 +1171,7 @@ class Administration:
@rules.command(name='remove', aliases=['delete']) @rules.command(name='remove', aliases=['delete'])
@commands.guild_only() @commands.guild_only()
@utils.custom_perms(manage_guild=True) @utils.can_run(manage_guild=True)
@utils.check_restricted()
async def rules_delete(self, ctx, rule: int): async def rules_delete(self, ctx, rule: int):
"""Removes one of the rules from the list of this server's rules """Removes one of the rules from the list of this server's rules
Provide a number to delete that rule Provide a number to delete that rule

12
cogs/birthday.py
View file

@ -112,8 +112,7 @@ class Birthday:
@commands.group(aliases=['birthdays'], invoke_without_command=True) @commands.group(aliases=['birthdays'], invoke_without_command=True)
@commands.guild_only() @commands.guild_only()
@utils.custom_perms(send_messages=True) @utils.can_run(send_messages=True)
@utils.check_restricted()
async def birthday(self, ctx, *, member: discord.Member = None): 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 """A command used to view the birthdays on this server; or a specific member's birthday
@ -139,8 +138,7 @@ class Birthday:
await ctx.send(str(e)) await ctx.send(str(e))
@birthday.command(name='add') @birthday.command(name='add')
@utils.custom_perms(send_messages=True) @utils.can_run(send_messages=True)
@utils.check_restricted()
async def _add_bday(self, ctx, *, date): async def _add_bday(self, ctx, *, date):
"""Used to link your birthday to your account """Used to link your birthday to your account
@ -162,8 +160,7 @@ class Birthday:
await ctx.send("I have just saved your birthday as {}".format(date)) await ctx.send("I have just saved your birthday as {}".format(date))
@birthday.command(name='remove') @birthday.command(name='remove')
@utils.custom_perms(send_messages=True) @utils.can_run(send_messages=True)
@utils.check_restricted()
async def _remove_bday(self, ctx): async def _remove_bday(self, ctx):
"""Used to unlink your birthday to your account """Used to unlink your birthday to your account
@ -178,8 +175,7 @@ class Birthday:
@birthday.command(name='alerts', aliases=['notifications']) @birthday.command(name='alerts', aliases=['notifications'])
@commands.guild_only() @commands.guild_only()
@utils.custom_perms(manage_guild=True) @utils.can_run(manage_guild=True)
@utils.check_restricted()
async def birthday_alerts_channel(self, ctx, channel: discord.TextChannel): async def birthday_alerts_channel(self, ctx, channel: discord.TextChannel):
"""Sets the notifications channel for birthday notifications """Sets the notifications channel for birthday notifications

9
cogs/blackjack.py
View file

@ -38,8 +38,7 @@ class Blackjack:
@commands.group(aliases=['bj'], invoke_without_command=True) @commands.group(aliases=['bj'], invoke_without_command=True)
@commands.guild_only() @commands.guild_only()
@utils.custom_perms(send_messages=True) @utils.can_run(send_messages=True)
@utils.check_restricted()
async def blackjack(self, ctx): async def blackjack(self, ctx):
"""Creates a game/joins the current running game of blackjack """Creates a game/joins the current running game of blackjack
@ -66,8 +65,7 @@ class Blackjack:
@blackjack.command(name='leave', aliases=['quit']) @blackjack.command(name='leave', aliases=['quit'])
@commands.guild_only() @commands.guild_only()
@utils.custom_perms(send_messages=True) @utils.can_run(send_messages=True)
@utils.check_restricted()
async def blackjack_leave(self, ctx): async def blackjack_leave(self, ctx):
"""Leaves the current game of blackjack """Leaves the current game of blackjack
@ -89,8 +87,7 @@ class Blackjack:
@blackjack.command(name='forcestop', aliases=['stop']) @blackjack.command(name='forcestop', aliases=['stop'])
@commands.guild_only() @commands.guild_only()
@utils.custom_perms(manage_guild=True) @utils.can_run(manage_guild=True)
@utils.check_restricted()
async def blackjack_stop(self, ctx): async def blackjack_stop(self, ctx):
"""Forces the game to stop, mostly for use if someone has gone afk """Forces the game to stop, mostly for use if someone has gone afk

4
cogs/chess.py
View file

@ -118,7 +118,7 @@ class Chess:
return game return game
@commands.group(invoke_without_command=True) @commands.group(invoke_without_command=True)
@checks.custom_perms(send_messages=True) @checks.can_run(send_messages=True)
async def chess(self, ctx, *, move): async def chess(self, ctx, *, move):
"""Moves a piece based on the notation provided """Moves a piece based on the notation provided
Notation for normal moves are {piece} to {position} based on the algebraic notation of the board (This is on the picture) Notation for normal moves are {piece} to {position} based on the algebraic notation of the board (This is on the picture)
@ -153,7 +153,7 @@ class Chess:
await self.bot.upload(link) await self.bot.upload(link)
@commands.command() @commands.command()
@checks.custom_perms(send_messages=True) @checks.can_run(send_messages=True)
async def chess_start(self, ctx, player2: discord.Member): async def chess_start(self, ctx, player2: discord.Member):
"""Starts a chess game with another player """Starts a chess game with another player
You can play one game on a single guild at a time You can play one game on a single guild at a time

6
cogs/hangman.py
View file

@ -79,7 +79,7 @@ class Hangman:
@commands.group(aliases=['hm'], invoke_without_command=True) @commands.group(aliases=['hm'], invoke_without_command=True)
@commands.guild_only() @commands.guild_only()
@commands.cooldown(1, 7, BucketType.user) @commands.cooldown(1, 7, BucketType.user)
@checks.custom_perms(send_messages=True) @checks.can_run(send_messages=True)
@checks.check_restricted() @checks.check_restricted()
async def hangman(self, ctx, *, guess): async def hangman(self, ctx, *, guess):
"""Makes a guess towards the server's currently running hangman game """Makes a guess towards the server's currently running hangman game
@ -128,7 +128,7 @@ class Hangman:
@hangman.command(name='create', aliases=['start']) @hangman.command(name='create', aliases=['start'])
@commands.guild_only() @commands.guild_only()
@checks.custom_perms(send_messages=True) @checks.can_run(send_messages=True)
@checks.check_restricted() @checks.check_restricted()
async def create_hangman(self, ctx): async def create_hangman(self, ctx):
"""This is used to create a new hangman game """This is used to create a new hangman game
@ -180,7 +180,7 @@ class Hangman:
@hangman.command(name='delete', aliases=['stop', 'remove', 'end']) @hangman.command(name='delete', aliases=['stop', 'remove', 'end'])
@commands.guild_only() @commands.guild_only()
@checks.custom_perms(kick_members=True) @checks.can_run(kick_members=True)
@checks.check_restricted() @checks.check_restricted()
async def stop_game(self, ctx): async def stop_game(self, ctx):
"""Force stops a game of hangman """Force stops a game of hangman

21
cogs/images.py
View file

@ -13,8 +13,7 @@ class Images:
self.bot = bot self.bot = bot
@commands.command(aliases=['rc']) @commands.command(aliases=['rc'])
@utils.custom_perms(send_messages=True) @utils.can_run(send_messages=True)
@utils.check_restricted()
async def cat(self, ctx): async def cat(self, ctx):
"""Use this to print a random cat image. """Use this to print a random cat image.
@ -32,8 +31,7 @@ class Images:
await ctx.send("I couldn't connect! Sorry no cats right now ;w;") await ctx.send("I couldn't connect! Sorry no cats right now ;w;")
@commands.command(aliases=['dog', 'rd']) @commands.command(aliases=['dog', 'rd'])
@utils.custom_perms(send_messages=True) @utils.can_run(send_messages=True)
@utils.check_restricted()
async def doggo(self, ctx): async def doggo(self, ctx):
"""Use this to print a random doggo image. """Use this to print a random doggo image.
@ -52,8 +50,7 @@ class Images:
await ctx.send(file=f) await ctx.send(file=f)
@commands.command(aliases=['snake']) @commands.command(aliases=['snake'])
@utils.custom_perms(send_messages=True) @utils.can_run(send_messages=True)
@utils.check_restricted()
async def snek(self, ctx): async def snek(self, ctx):
"""Use this to print a random snek image. """Use this to print a random snek image.
@ -74,8 +71,7 @@ class Images:
await ctx.send(file=f) await ctx.send(file=f)
@commands.command() @commands.command()
@utils.custom_perms(send_messages=True) @utils.can_run(send_messages=True)
@utils.check_restricted()
async def horse(self, ctx): async def horse(self, ctx):
"""Use this to print a random horse image. """Use this to print a random horse image.
@ -97,8 +93,7 @@ class Images:
@commands.command() @commands.command()
@commands.guild_only() @commands.guild_only()
@utils.custom_perms(send_messages=True) @utils.can_run(send_messages=True)
@utils.check_restricted()
async def avatar(self, ctx, member: discord.Member = None): async def avatar(self, ctx, member: discord.Member = None):
"""Provides an image for the provided person's avatar (yours if no other member is provided) """Provides an image for the provided person's avatar (yours if no other member is provided)
@ -128,8 +123,7 @@ class Images:
await ctx.send(url) await ctx.send(url)
@commands.command() @commands.command()
@utils.custom_perms(send_messages=True) @utils.can_run(send_messages=True)
@utils.check_restricted()
async def derpi(self, ctx, *search: str): async def derpi(self, ctx, *search: str):
"""Provides a random image from the first page of derpibooru.org for the following term """Provides a random image from the first page of derpibooru.org for the following term
@ -197,8 +191,7 @@ class Images:
await ctx.send(image_link) await ctx.send(image_link)
@commands.command() @commands.command()
@utils.custom_perms(send_messages=True) @utils.can_run(send_messages=True)
@utils.check_restricted()
async def e621(self, ctx, *, tags: str): async def e621(self, ctx, *, tags: str):
"""Searches for a random image from e621.net """Searches for a random image from e621.net
Format for the search terms need to be 'search term 1, search term 2, etc.' Format for the search terms need to be 'search term 1, search term 2, etc.'

15
cogs/interaction.py
View file

@ -156,8 +156,7 @@ class Interaction:
@commands.command() @commands.command()
@commands.guild_only() @commands.guild_only()
@utils.custom_perms(send_messages=True) @utils.can_run(send_messages=True)
@utils.check_restricted()
async def hug(self, ctx, user=None): async def hug(self, ctx, user=None):
"""Makes me hug a person! """Makes me hug a person!
@ -197,8 +196,7 @@ class Interaction:
@commands.command(aliases=['1v1']) @commands.command(aliases=['1v1'])
@commands.guild_only() @commands.guild_only()
@commands.cooldown(1, 20, BucketType.user) @commands.cooldown(1, 20, BucketType.user)
@utils.custom_perms(send_messages=True) @utils.can_run(send_messages=True)
@utils.check_restricted()
async def battle(self, ctx, player2=None): async def battle(self, ctx, player2=None):
"""Challenges the mentioned user to a battle """Challenges the mentioned user to a battle
@ -254,8 +252,7 @@ class Interaction:
@commands.command() @commands.command()
@commands.guild_only() @commands.guild_only()
@utils.custom_perms(send_messages=True) @utils.can_run(send_messages=True)
@utils.check_restricted()
async def accept(self, ctx): async def accept(self, ctx):
"""Accepts the battle challenge """Accepts the battle challenge
@ -335,8 +332,7 @@ class Interaction:
@commands.command() @commands.command()
@commands.guild_only() @commands.guild_only()
@utils.custom_perms(send_messages=True) @utils.can_run(send_messages=True)
@utils.check_restricted()
async def decline(self, ctx): async def decline(self, ctx):
"""Declines the battle challenge """Declines the battle challenge
@ -363,8 +359,7 @@ class Interaction:
@commands.command() @commands.command()
@commands.guild_only() @commands.guild_only()
@commands.cooldown(1, 10, BucketType.user) @commands.cooldown(1, 10, BucketType.user)
@utils.custom_perms(send_messages=True) @utils.can_run(send_messages=True)
@utils.check_restricted()
async def boop(self, ctx, boopee: discord.Member = None, *, message=""): async def boop(self, ctx, boopee: discord.Member = None, *, message=""):
"""Boops the mentioned person """Boops the mentioned person

12
cogs/links.py
View file

@ -16,8 +16,7 @@ class Links:
self.bot = bot self.bot = bot
@commands.command(aliases=['g']) @commands.command(aliases=['g'])
@utils.custom_perms(send_messages=True) @utils.can_run(send_messages=True)
@utils.check_restricted()
async def google(self, ctx, *, query: str): async def google(self, ctx, *, query: str):
"""Searches google for a provided query """Searches google for a provided query
@ -71,8 +70,7 @@ class Links:
await ctx.send(fmt) await ctx.send(fmt)
@commands.command(aliases=['yt']) @commands.command(aliases=['yt'])
@utils.custom_perms(send_messages=True) @utils.can_run(send_messages=True)
@utils.check_restricted()
async def youtube(self, ctx, *, query: str): async def youtube(self, ctx, *, query: str):
"""Searches youtube for a provided query """Searches youtube for a provided query
@ -107,8 +105,7 @@ class Links:
await ctx.send(fmt) await ctx.send(fmt)
@commands.command() @commands.command()
@utils.custom_perms(send_messages=True) @utils.can_run(send_messages=True)
@utils.check_restricted()
async def wiki(self, ctx, *, query: str): async def wiki(self, ctx, *, query: str):
"""Pulls the top match for a specific term from wikipedia, and returns the result """Pulls the top match for a specific term from wikipedia, and returns the result
@ -147,8 +144,7 @@ class Links:
snippet)) snippet))
@commands.command() @commands.command()
@utils.custom_perms(send_messages=True) @utils.can_run(send_messages=True)
@utils.check_restricted()
async def urban(self, ctx, *, msg: str): async def urban(self, ctx, *, msg: str):
"""Pulls the top urbandictionary.com definition for a term """Pulls the top urbandictionary.com definition for a term

27
cogs/misc.py
View file

@ -23,8 +23,7 @@ class Miscallaneous:
self.process.cpu_percent() self.process.cpu_percent()
@commands.command() @commands.command()
@utils.custom_perms(send_messages=True) @utils.can_run(send_messages=True)
@utils.check_restricted()
async def help(self, ctx, *, command=None): async def help(self, ctx, *, command=None):
"""This command is used to provide a link to the help URL. """This command is used to provide a link to the help URL.
This can be called on a command to provide more information about that command This can be called on a command to provide more information about that command
@ -110,8 +109,7 @@ class Miscallaneous:
await ctx.send(embed=embed) await ctx.send(embed=embed)
@commands.command(aliases=["coin"]) @commands.command(aliases=["coin"])
@utils.custom_perms(send_messages=True) @utils.can_run(send_messages=True)
@utils.check_restricted()
async def coinflip(self, ctx): async def coinflip(self, ctx):
"""Flips a coin and responds with either heads or tails """Flips a coin and responds with either heads or tails
@ -122,8 +120,7 @@ class Miscallaneous:
await ctx.send(result) await ctx.send(result)
@commands.command() @commands.command()
@utils.custom_perms(send_messages=True) @utils.can_run(send_messages=True)
@utils.check_restricted()
async def say(self, ctx, *, msg: str): async def say(self, ctx, *, msg: str):
"""Tells the bot to repeat what you say """Tells the bot to repeat what you say
@ -137,8 +134,7 @@ class Miscallaneous:
pass pass
@commands.command() @commands.command()
@utils.custom_perms(send_messages=True) @utils.can_run(send_messages=True)
@utils.check_restricted()
async def calendar(self, ctx, month: str = None, year: int = None): async def calendar(self, ctx, month: str = None, year: int = None):
"""Provides a printout of the current month's calendar """Provides a printout of the current month's calendar
Provide month and year to print the calendar of that year and month Provide month and year to print the calendar of that year and month
@ -177,8 +173,7 @@ class Miscallaneous:
await ctx.send("```\n{}```".format(cal)) await ctx.send("```\n{}```".format(cal))
@commands.command(aliases=['about']) @commands.command(aliases=['about'])
@utils.custom_perms(send_messages=True) @utils.can_run(send_messages=True)
@utils.check_restricted()
async def info(self, ctx): async def info(self, ctx):
"""This command can be used to print out some of my information""" """This command can be used to print out some of my information"""
# fmt is a dictionary so we can set the key to it's output, then print both # fmt is a dictionary so we can set the key to it's output, then print both
@ -248,8 +243,7 @@ class Miscallaneous:
await ctx.send(embed=embed) await ctx.send(embed=embed)
@commands.command() @commands.command()
@utils.custom_perms(send_messages=True) @utils.can_run(send_messages=True)
@utils.check_restricted()
async def uptime(self, ctx): async def uptime(self, ctx):
"""Provides a printout of the current bot's uptime """Provides a printout of the current bot's uptime
@ -261,8 +255,7 @@ class Miscallaneous:
await ctx.send("I've just restarted and not quite ready yet...gimme time I'm not a morning pony :c") await ctx.send("I've just restarted and not quite ready yet...gimme time I'm not a morning pony :c")
@commands.command(aliases=['invite']) @commands.command(aliases=['invite'])
@utils.custom_perms(send_messages=True) @utils.can_run(send_messages=True)
@utils.check_restricted()
async def addbot(self, ctx): async def addbot(self, ctx):
"""Provides a link that you can use to add me to a server """Provides a link that you can use to add me to a server
@ -287,8 +280,7 @@ class Miscallaneous:
.format(discord.utils.oauth_url(app_info.id, perms))) .format(discord.utils.oauth_url(app_info.id, perms)))
@commands.command(enabled=False) @commands.command(enabled=False)
@utils.custom_perms(send_messages=True) @utils.can_run(send_messages=True)
@utils.check_restricted()
async def joke(self, ctx): async def joke(self, ctx):
"""Prints a random riddle """Prints a random riddle
@ -298,8 +290,7 @@ class Miscallaneous:
pass pass
@commands.command() @commands.command()
@utils.custom_perms(send_messages=True) @utils.can_run(send_messages=True)
@utils.check_restricted()
async def roll(self, ctx, *, notation: str = "d6"): async def roll(self, ctx, *, notation: str = "d6"):
"""Rolls a die based on the notation given """Rolls a die based on the notation given
Format should be #d# Format should be #d#

15
cogs/mod.py
View file

@ -14,8 +14,7 @@ class Moderation:
@commands.command() @commands.command()
@commands.guild_only() @commands.guild_only()
@utils.custom_perms(kick_members=True) @utils.can_run(kick_members=True)
@utils.check_restricted()
async def kick(self, ctx, member: discord.Member, *, reason=None): async def kick(self, ctx, member: discord.Member, *, reason=None):
"""Used to kick a member from this server """Used to kick a member from this server
@ -29,8 +28,7 @@ class Moderation:
@commands.command() @commands.command()
@commands.guild_only() @commands.guild_only()
@utils.custom_perms(ban_members=True) @utils.can_run(ban_members=True)
@utils.check_restricted()
async def unban(self, ctx, member_id: int): async def unban(self, ctx, member_id: int):
"""Used to unban a member from this server """Used to unban a member from this server
Due to the fact that I cannot find a user without being in a server with them Due to the fact that I cannot find a user without being in a server with them
@ -51,8 +49,7 @@ class Moderation:
@commands.command() @commands.command()
@commands.guild_only() @commands.guild_only()
@utils.custom_perms(ban_members=True) @utils.can_run(ban_members=True)
@utils.check_restricted()
async def ban(self, ctx, member, *, reason=None): async def ban(self, ctx, member, *, reason=None):
"""Used to ban a member """Used to ban a member
This can be used to ban someone preemptively as well. This can be used to ban someone preemptively as well.
@ -93,8 +90,7 @@ class Moderation:
@commands.command() @commands.command()
@commands.guild_only() @commands.guild_only()
@utils.custom_perms(manage_messages=True) @utils.can_run(manage_messages=True)
@utils.check_restricted()
async def purge(self, ctx, limit: int = 100): async def purge(self, ctx, limit: int = 100):
"""This command is used to a purge a number of messages from the channel """This command is used to a purge a number of messages from the channel
@ -116,8 +112,7 @@ class Moderation:
@commands.command() @commands.command()
@commands.guild_only() @commands.guild_only()
@utils.custom_perms(manage_messages=True) @utils.can_run(manage_messages=True)
@utils.check_restricted()
async def prune(self, ctx, *specifications): async def prune(self, ctx, *specifications):
"""This command can be used to prune messages from certain members """This command can be used to prune messages from certain members
Mention any user you want to prune messages from; if no members are mentioned, the messages removed will be mine Mention any user you want to prune messages from; if no members are mentioned, the messages removed will be mine

9
cogs/osu.py
View file

@ -55,8 +55,7 @@ class Osu:
self.osu_users[member] = user self.osu_users[member] = user
@commands.group(invoke_without_command=True) @commands.group(invoke_without_command=True)
@utils.custom_perms(send_messages=True) @utils.can_run(send_messages=True)
@utils.check_restricted()
async def osu(self, ctx, member: discord.Member = None): async def osu(self, ctx, member: discord.Member = None):
"""Provides basic information about a specific user """Provides basic information about a specific user
@ -88,8 +87,7 @@ class Osu:
await ctx.send(embed=e) await ctx.send(embed=e)
@osu.command(name='add', aliases=['create', 'connect']) @osu.command(name='add', aliases=['create', 'connect'])
@utils.custom_perms(send_messages=True) @utils.can_run(send_messages=True)
@utils.check_restricted()
async def osu_add(self, ctx, *, username): async def osu_add(self, ctx, *, username):
"""Links an osu account to your discord account """Links an osu account to your discord account
@ -112,8 +110,7 @@ class Osu:
await ctx.send("I have just saved your Osu user {}".format(author.display_name)) await ctx.send("I have just saved your Osu user {}".format(author.display_name))
@osu.command(name='score', aliases=['scores']) @osu.command(name='score', aliases=['scores'])
@utils.custom_perms(send_messages=True) @utils.can_run(send_messages=True)
@utils.check_restricted()
async def osu_scores(self, ctx, *data): async def osu_scores(self, ctx, *data):
"""Find the top x osu scores for a provided member """Find the top x osu scores for a provided member
Note: You can only get the top 50 songs for a user Note: You can only get the top 50 songs for a user

10
cogs/overwatch.py
View file

@ -20,7 +20,6 @@ class Overwatch:
self.bot = bot self.bot = bot
@commands.group() @commands.group()
@utils.check_restricted()
async def ow(self, ctx): async def ow(self, ctx):
"""Command used to lookup information on your own user, or on another's """Command used to lookup information on your own user, or on another's
When adding your battletag, it is quite picky, use the exact format user#xxxx When adding your battletag, it is quite picky, use the exact format user#xxxx
@ -29,8 +28,7 @@ class Overwatch:
pass pass
@ow.command(name="stats") @ow.command(name="stats")
@utils.custom_perms(send_messages=True) @utils.can_run(send_messages=True)
@utils.check_restricted()
async def ow_stats(self, ctx, user: discord.Member = None, hero: str = ""): async def ow_stats(self, ctx, user: discord.Member = None, hero: str = ""):
"""Prints out a basic overview of a member's stats """Prints out a basic overview of a member's stats
Provide a hero after the member to get stats for that specific hero Provide a hero after the member to get stats for that specific hero
@ -90,8 +88,7 @@ class Overwatch:
await ctx.send("Overwatch stats for {}: ```py\n{}```".format(user.name, fmt)) await ctx.send("Overwatch stats for {}: ```py\n{}```".format(user.name, fmt))
@ow.command(name="add") @ow.command(name="add")
@utils.custom_perms(send_messages=True) @utils.can_run(send_messages=True)
@utils.check_restricted()
async def add(self, ctx, bt: str): async def add(self, ctx, bt: str):
"""Saves your battletag for looking up information """Saves your battletag for looking up information
@ -123,8 +120,7 @@ class Overwatch:
await ctx.send("I have just saved your battletag {}".format(ctx.message.author.mention)) await ctx.send("I have just saved your battletag {}".format(ctx.message.author.mention))
@ow.command(name="delete", aliases=['remove']) @ow.command(name="delete", aliases=['remove'])
@utils.custom_perms(send_messages=True) @utils.can_run(send_messages=True)
@utils.check_restricted()
async def delete(self, ctx): async def delete(self, ctx):
"""Removes your battletag from the records """Removes your battletag from the records

20
cogs/owner.py
View file

@ -91,7 +91,7 @@ class Owner:
await self.bot.owner.send(embed=embed) await self.bot.owner.send(embed=embed)
@commands.command(hidden=True) @commands.command(hidden=True)
@commands.check(utils.is_owner) @utils.can_run(ownership=True)
async def repl(self, ctx): async def repl(self, ctx):
msg = ctx.message msg = ctx.message
@ -184,7 +184,7 @@ class Owner:
await ctx.send('Unexpected error: `{}`'.format(e)) await ctx.send('Unexpected error: `{}`'.format(e))
@commands.command() @commands.command()
@commands.check(utils.is_owner) @utils.can_run(ownership=True)
async def sendtochannel(self, ctx, cid: int, *, message): async def sendtochannel(self, ctx, cid: int, *, message):
"""Sends a message to a provided channel, by ID""" """Sends a message to a provided channel, by ID"""
channel = self.bot.get_channel(cid) channel = self.bot.get_channel(cid)
@ -195,7 +195,7 @@ class Owner:
pass pass
@commands.command() @commands.command()
@commands.check(utils.is_owner) @utils.can_run(ownership=True)
async def debug(self, ctx, *, body: str): async def debug(self, ctx, *, body: str):
env = { env = {
'bot': self.bot, 'bot': self.bot,
@ -246,7 +246,7 @@ class Owner:
await ctx.send("Content too large for me to print!") await ctx.send("Content too large for me to print!")
@commands.command() @commands.command()
@commands.check(utils.is_owner) @utils.can_run(ownership=True)
async def bash(self, ctx, *, cmd: str): async def bash(self, ctx, *, cmd: str):
"""Runs a bash command""" """Runs a bash command"""
output = subprocess.check_output("{}; exit 0".format(cmd), stderr=subprocess.STDOUT, shell=True) output = subprocess.check_output("{}; exit 0".format(cmd), stderr=subprocess.STDOUT, shell=True)
@ -256,7 +256,7 @@ class Owner:
await ctx.send("No output for `{}`".format(cmd)) await ctx.send("No output for `{}`".format(cmd))
@commands.command() @commands.command()
@commands.check(utils.is_owner) @utils.can_run(ownership=True)
async def shutdown(self, ctx): async def shutdown(self, ctx):
"""Shuts the bot down""" """Shuts the bot down"""
fmt = 'Shutting down, I will miss you {0.author.name}' fmt = 'Shutting down, I will miss you {0.author.name}'
@ -265,21 +265,21 @@ class Owner:
await self.bot.close() await self.bot.close()
@commands.command() @commands.command()
@commands.check(utils.is_owner) @utils.can_run(ownership=True)
async def name(self, ctx, new_nick: str): async def name(self, ctx, new_nick: str):
"""Changes the bot's name""" """Changes the bot's name"""
await self.bot.user.edit(username=new_nick) await self.bot.user.edit(username=new_nick)
await ctx.send('Changed username to ' + new_nick) await ctx.send('Changed username to ' + new_nick)
@commands.command() @commands.command()
@commands.check(utils.is_owner) @utils.can_run(ownership=True)
async def status(self, ctx, *, status: str): async def status(self, ctx, *, status: str):
"""Changes the bot's 'playing' status""" """Changes the bot's 'playing' status"""
await self.bot.change_presence(activity=discord.Game(name=status, type=0)) await self.bot.change_presence(activity=discord.Game(name=status, type=0))
await ctx.send("Just changed my status to '{}'!".format(status)) await ctx.send("Just changed my status to '{}'!".format(status))
@commands.command() @commands.command()
@commands.check(utils.is_owner) @utils.can_run(ownership=True)
async def load(self, ctx, *, module: str): async def load(self, ctx, *, module: str):
"""Loads a module""" """Loads a module"""
@ -297,7 +297,7 @@ class Owner:
await ctx.send(fmt.format(type(error).__name__, error)) await ctx.send(fmt.format(type(error).__name__, error))
@commands.command() @commands.command()
@commands.check(utils.is_owner) @utils.can_run(ownership=True)
async def unload(self, ctx, *, module: str): async def unload(self, ctx, *, module: str):
"""Unloads a module""" """Unloads a module"""
@ -310,7 +310,7 @@ class Owner:
await ctx.send("I have just unloaded the {} module".format(module)) await ctx.send("I have just unloaded the {} module".format(module))
@commands.command() @commands.command()
@commands.check(utils.is_owner) @utils.can_run(ownership=True)
async def reload(self, ctx, *, module: str): async def reload(self, ctx, *, module: str):
"""Reloads a module""" """Reloads a module"""

21
cogs/picarto.py
View file

@ -129,8 +129,7 @@ class Picarto:
pass pass
@commands.group(invoke_without_command=True) @commands.group(invoke_without_command=True)
@utils.custom_perms(send_messages=True) @utils.can_run(send_messages=True)
@utils.check_restricted()
async def picarto(self, ctx, member: discord.Member = None): async def picarto(self, ctx, member: discord.Member = None):
"""This command can be used to view Picarto stats about a certain member """This command can be used to view Picarto stats about a certain member
@ -151,8 +150,7 @@ class Picarto:
@picarto.command(name='add') @picarto.command(name='add')
@commands.guild_only() @commands.guild_only()
@utils.custom_perms(send_messages=True) @utils.can_run(send_messages=True)
@utils.check_restricted()
async def add_picarto_url(self, ctx, url: str): async def add_picarto_url(self, ctx, url: str):
"""Saves your user's picarto URL """Saves your user's picarto URL
@ -206,8 +204,7 @@ class Picarto:
ctx.message.author.mention)) ctx.message.author.mention))
@picarto.command(name='remove', aliases=['delete']) @picarto.command(name='remove', aliases=['delete'])
@utils.custom_perms(send_messages=True) @utils.can_run(send_messages=True)
@utils.check_restricted()
async def remove_picarto_url(self, ctx): async def remove_picarto_url(self, ctx):
"""Removes your picarto URL""" """Removes your picarto URL"""
key = str(ctx.message.author.id) key = str(ctx.message.author.id)
@ -226,8 +223,7 @@ class Picarto:
@picarto.command(name='alerts') @picarto.command(name='alerts')
@commands.guild_only() @commands.guild_only()
@utils.custom_perms(manage_guild=True) @utils.can_run(manage_guild=True)
@utils.check_restricted()
async def picarto_alerts_channel(self, ctx, channel: discord.TextChannel): async def picarto_alerts_channel(self, ctx, channel: discord.TextChannel):
"""Sets the notifications channel for picarto notifications """Sets the notifications channel for picarto notifications
@ -245,8 +241,7 @@ class Picarto:
@picarto.group(invoke_without_command=True) @picarto.group(invoke_without_command=True)
@commands.guild_only() @commands.guild_only()
@utils.custom_perms(send_messages=True) @utils.can_run(send_messages=True)
@utils.check_restricted()
async def notify(self, ctx): async def notify(self, ctx):
"""This can be used to turn picarto notifications on or off """This can be used to turn picarto notifications on or off
Call this command by itself, to add this guild to the list of guilds to be notified Call this command by itself, to add this guild to the list of guilds to be notified
@ -274,8 +269,7 @@ class Picarto:
@notify.command(name='on', aliases=['start,yes']) @notify.command(name='on', aliases=['start,yes'])
@commands.guild_only() @commands.guild_only()
@utils.custom_perms(send_messages=True) @utils.can_run(send_messages=True)
@utils.check_restricted()
async def notify_on(self, ctx): async def notify_on(self, ctx):
"""Turns picarto notifications on """Turns picarto notifications on
@ -296,8 +290,7 @@ class Picarto:
@notify.command(name='off', aliases=['stop,no']) @notify.command(name='off', aliases=['stop,no'])
@commands.guild_only() @commands.guild_only()
@utils.custom_perms(send_messages=True) @utils.can_run(send_messages=True)
@utils.check_restricted()
async def notify_off(self, ctx): async def notify_off(self, ctx):
"""Turns picarto notifications off """Turns picarto notifications off

3
cogs/polls.py
View file

@ -72,8 +72,7 @@ class Polls:
@commands.command() @commands.command()
@commands.guild_only() @commands.guild_only()
@utils.custom_perms(send_messages=True) @utils.can_run(send_messages=True)
@utils.check_restricted()
async def poll(self, ctx, *, question): async def poll(self, ctx, *, question):
"""Sets up a poll based on the question that you have provided. """Sets up a poll based on the question that you have provided.
Provide the question on the first line and the options on the following lines Provide the question on the first line and the options on the following lines

12
cogs/raffle.py
View file

@ -98,8 +98,7 @@ class Raffle:
@commands.command() @commands.command()
@commands.guild_only() @commands.guild_only()
@utils.custom_perms(send_messages=True) @utils.can_run(send_messages=True)
@utils.check_restricted()
async def raffles(self, ctx): async def raffles(self, ctx):
"""Used to print the current running raffles on the server """Used to print the current running raffles on the server
@ -124,8 +123,7 @@ class Raffle:
@commands.group(invoke_without_command=True) @commands.group(invoke_without_command=True)
@commands.guild_only() @commands.guild_only()
@utils.custom_perms(send_messages=True) @utils.can_run(send_messages=True)
@utils.check_restricted()
async def raffle(self, ctx, raffle_id: int = 0): async def raffle(self, ctx, raffle_id: int = 0):
"""Used to enter a raffle running on this server """Used to enter a raffle running on this server
If there is more than one raffle running, provide an ID of the raffle you want to enter If there is more than one raffle running, provide an ID of the raffle you want to enter
@ -186,8 +184,7 @@ class Raffle:
@raffle.command(name='create', aliases=['start', 'begin', 'add']) @raffle.command(name='create', aliases=['start', 'begin', 'add'])
@commands.guild_only() @commands.guild_only()
@utils.custom_perms(kick_members=True) @utils.can_run(kick_members=True)
@utils.check_restricted()
async def raffle_create(self, ctx): async def raffle_create(self, ctx):
"""This is used in order to create a new server raffle """This is used in order to create a new server raffle
@ -281,8 +278,7 @@ class Raffle:
@raffle.command(name='alerts') @raffle.command(name='alerts')
@commands.guild_only() @commands.guild_only()
@utils.custom_perms(manage_guild=True) @utils.can_run(manage_guild=True)
@utils.check_restricted()
async def raffle_alerts_channel(self, ctx, channel: discord.TextChannel): async def raffle_alerts_channel(self, ctx, channel: discord.TextChannel):
"""Sets the notifications channel for raffle notifications """Sets the notifications channel for raffle notifications

33
cogs/roles.py
View file

@ -15,8 +15,7 @@ class Roles:
@commands.command(aliases=['color']) @commands.command(aliases=['color'])
@commands.guild_only() @commands.guild_only()
@utils.custom_perms(send_messages=True) @utils.can_run(send_messages=True)
@utils.check_restricted()
async def colour(self, ctx, role_colour: discord.Colour): async def colour(self, ctx, role_colour: discord.Colour):
"""Used to give yourself a role matching the colour given. """Used to give yourself a role matching the colour given.
If the role doesn't exist, it will be created. Names such as red, blue, yellow, etc. can be used. If the role doesn't exist, it will be created. Names such as red, blue, yellow, etc. can be used.
@ -62,8 +61,7 @@ class Roles:
@commands.group(aliases=['roles'], invoke_without_command=True) @commands.group(aliases=['roles'], invoke_without_command=True)
@commands.guild_only() @commands.guild_only()
@utils.custom_perms(send_messages=True) @utils.can_run(send_messages=True)
@utils.check_restricted()
async def role(self, ctx): async def role(self, ctx):
"""This command can be used to modify the roles on the server. """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 Pass no subcommands and this will print the roles currently available on this server
@ -86,8 +84,7 @@ class Roles:
@role.command(name='remove') @role.command(name='remove')
@commands.guild_only() @commands.guild_only()
@utils.custom_perms(manage_roles=True) @utils.can_run(manage_roles=True)
@utils.check_restricted()
async def remove_role(self, ctx): async def remove_role(self, ctx):
"""Use this to remove roles from a number of members """Use this to remove roles from a number of members
@ -149,8 +146,7 @@ class Roles:
@role.command(name='add', aliases=['give', 'assign']) @role.command(name='add', aliases=['give', 'assign'])
@commands.guild_only() @commands.guild_only()
@utils.custom_perms(manage_roles=True) @utils.can_run(manage_roles=True)
@utils.check_restricted()
async def add_role(self, ctx): async def add_role(self, ctx):
"""Use this to add a role to multiple members. """Use this to add a role to multiple members.
Provide the list of members, and I'll ask for the role Provide the list of members, and I'll ask for the role
@ -206,8 +202,7 @@ class Roles:
@role.command(name='delete') @role.command(name='delete')
@commands.guild_only() @commands.guild_only()
@utils.custom_perms(manage_roles=True) @utils.can_run(manage_roles=True)
@utils.check_restricted()
async def delete_role(self, ctx, *, role: discord.Role = None): async def delete_role(self, ctx, *, role: discord.Role = None):
"""This command can be used to delete one of the roles from the server """This command can be used to delete one of the roles from the server
@ -249,8 +244,7 @@ class Roles:
@role.command(name='create') @role.command(name='create')
@commands.guild_only() @commands.guild_only()
@utils.custom_perms(manage_roles=True) @utils.can_run(manage_roles=True)
@utils.check_restricted()
async def create_role(self, ctx): async def create_role(self, ctx):
"""This command can be used to create a new role for this server """This command can be used to create a new role for this server
A prompt will follow asking what settings you would like for this new role A prompt will follow asking what settings you would like for this new role
@ -366,8 +360,7 @@ class Roles:
@commands.group(invoke_without_command=True) @commands.group(invoke_without_command=True)
@commands.guild_only() @commands.guild_only()
@utils.custom_perms(send_messages=True) @utils.can_run(send_messages=True)
@utils.check_restricted()
async def assign(self, ctx, *role: discord.Role): async def assign(self, ctx, *role: discord.Role):
"""Assigns the provided role(s) to you, if they can be assigned """Assigns the provided role(s) to you, if they can be assigned
@ -400,8 +393,7 @@ class Roles:
@commands.command() @commands.command()
@commands.guild_only() @commands.guild_only()
@utils.custom_perms(send_messages=True) @utils.can_run(send_messages=True)
@utils.check_restricted()
async def unassign(self, ctx, *role: discord.Role): async def unassign(self, ctx, *role: discord.Role):
"""Unassigns the provided role(s) to you, if they can be assigned """Unassigns the provided role(s) to you, if they can be assigned
@ -434,8 +426,7 @@ class Roles:
@assign.command(name='add') @assign.command(name='add')
@commands.guild_only() @commands.guild_only()
@utils.custom_perms(manage_roles=True) @utils.can_run(manage_roles=True)
@utils.check_restricted()
async def _add_assigns(self, ctx, *role: discord.Role): async def _add_assigns(self, ctx, *role: discord.Role):
"""Adds the provided role(s) to the list of available self-assignable roles """Adds the provided role(s) to the list of available self-assignable roles
@ -464,8 +455,7 @@ class Roles:
@assign.command(name='list') @assign.command(name='list')
@commands.guild_only() @commands.guild_only()
@utils.custom_perms(send_messages=True) @utils.can_run(send_messages=True)
@utils.check_restricted()
async def _list_assigns(self, ctx): async def _list_assigns(self, ctx):
"""Lists the roles that can be self-assigned """Lists the roles that can be self-assigned
@ -495,8 +485,7 @@ class Roles:
@assign.command(name='remove', aliases=['delete']) @assign.command(name='remove', aliases=['delete'])
@commands.guild_only() @commands.guild_only()
@utils.custom_perms(manage_roles=True) @utils.can_run(manage_roles=True)
@utils.check_restricted()
async def _delete_assigns(self, ctx, *role: discord.Role): async def _delete_assigns(self, ctx, *role: discord.Role):
"""Removes the provided role(s) from the list of available self-assignable roles """Removes the provided role(s) from the list of available self-assignable roles

6
cogs/roulette.py
View file

@ -36,8 +36,7 @@ class Roulette:
@commands.group(invoke_without_command=True) @commands.group(invoke_without_command=True)
@commands.guild_only() @commands.guild_only()
@utils.custom_perms(send_messages=True) @utils.can_run(send_messages=True)
@utils.check_restricted()
async def roulette(self, ctx): async def roulette(self, ctx):
"""Joins the current running roulette """Joins the current running roulette
@ -56,8 +55,7 @@ class Roulette:
@roulette.command(name='start', aliases=['create']) @roulette.command(name='start', aliases=['create'])
@commands.guild_only() @commands.guild_only()
@utils.custom_perms(kick_members=True) @utils.can_run(kick_members=True)
@utils.check_restricted()
async def roulette_start(self, ctx, time: int=5): async def roulette_start(self, ctx, time: int=5):
"""Starts a roulette, that will end in one of the entrants being kicked from the server """Starts a roulette, that will end in one of the entrants being kicked from the server
By default, the roulette will end in 5 minutes; provide a number (up to 30) By default, the roulette will end in 5 minutes; provide a number (up to 30)

6
cogs/spotify.py
View file

@ -45,8 +45,7 @@ class Spotify:
return data.get("expires_in") return data.get("expires_in")
@commands.group(invoke_without_command=True) @commands.group(invoke_without_command=True)
@utils.custom_perms(send_messages=True) @utils.can_run(send_messages=True)
@utils.check_restricted()
async def spotify(self, ctx, *, query): async def spotify(self, ctx, *, query):
"""Searches Spotify for a song, giving you the link you can use to listen in. Give the query to search for """Searches Spotify for a song, giving you the link you can use to listen in. Give the query to search for
and it will search by title/artist for the best match and it will search by title/artist for the best match
@ -65,8 +64,7 @@ class Spotify:
await ctx.send("Couldn't find a song for:\n{}".format(query)) await ctx.send("Couldn't find a song for:\n{}".format(query))
@spotify.command() @spotify.command()
@utils.custom_perms(send_messages=True) @utils.can_run(send_messages=True)
@utils.check_restricted()
async def playlist(self, ctx, *, query): async def playlist(self, ctx, *, query):
"""Searches Spotify for a playlist, giving you the link you can use to listen in. Give the query to search for """Searches Spotify for a playlist, giving you the link you can use to listen in. Give the query to search for
and it will search for the best match and it will search for the best match

30
cogs/stats.py
View file

@ -62,8 +62,7 @@ class Stats:
@commands.command() @commands.command()
@commands.guild_only() @commands.guild_only()
@utils.custom_perms(send_messages=True) @utils.can_run(send_messages=True)
@utils.check_restricted()
async def serverinfo(self, ctx): async def serverinfo(self, ctx):
"""Provides information about the server """Provides information about the server
@ -96,8 +95,7 @@ class Stats:
@commands.command() @commands.command()
@commands.guild_only() @commands.guild_only()
@utils.custom_perms(send_messages=True) @utils.can_run(send_messages=True)
@utils.check_restricted()
async def userinfo(self, ctx, *, user: discord.Member = None): async def userinfo(self, ctx, *, user: discord.Member = None):
"""Provides information about a provided member """Provides information about a provided member
@ -130,15 +128,13 @@ class Stats:
await ctx.send(embed=embed) await ctx.send(embed=embed)
@commands.group() @commands.group()
@utils.custom_perms(send_messages=True) @utils.can_run(send_messages=True)
@utils.check_restricted()
async def command(self, ctx): async def command(self, ctx):
pass pass
@command.command(name="stats") @command.command(name="stats")
@commands.guild_only() @commands.guild_only()
@utils.custom_perms(send_messages=True) @utils.can_run(send_messages=True)
@utils.check_restricted()
async def command_stats(self, ctx, *, command): async def command_stats(self, ctx, *, command):
"""This command can be used to view some usage stats about a specific command """This command can be used to view some usage stats about a specific command
@ -176,8 +172,7 @@ class Stats:
await ctx.send(fmt) await ctx.send(fmt)
@command.command(name="leaderboard") @command.command(name="leaderboard")
@utils.custom_perms(send_messages=True) @utils.can_run(send_messages=True)
@utils.check_restricted()
async def command_leaderboard(self, ctx, option="server"): async def command_leaderboard(self, ctx, option="server"):
"""This command can be used to print a leaderboard of commands """This command can be used to print a leaderboard of commands
Provide 'server' to print a leaderboard for this server Provide 'server' to print a leaderboard for this server
@ -236,8 +231,7 @@ class Stats:
@commands.command() @commands.command()
@commands.guild_only() @commands.guild_only()
@utils.custom_perms(send_messages=True) @utils.can_run(send_messages=True)
@utils.check_restricted()
async def mostboops(self, ctx): async def mostboops(self, ctx):
"""Shows the person you have 'booped' the most, as well as how many times """Shows the person you have 'booped' the most, as well as how many times
@ -269,8 +263,7 @@ class Stats:
@commands.command() @commands.command()
@commands.guild_only() @commands.guild_only()
@utils.custom_perms(send_messages=True) @utils.can_run(send_messages=True)
@utils.check_restricted()
async def listboops(self, ctx): async def listboops(self, ctx):
"""Lists all the users you have booped and the amount of times """Lists all the users you have booped and the amount of times
@ -306,8 +299,7 @@ class Stats:
@commands.command() @commands.command()
@commands.guild_only() @commands.guild_only()
@utils.custom_perms(send_messages=True) @utils.can_run(send_messages=True)
@utils.check_restricted()
async def leaderboard(self, ctx): async def leaderboard(self, ctx):
"""Prints a leaderboard of everyone in the server's battling record """Prints a leaderboard of everyone in the server's battling record
@ -345,8 +337,7 @@ class Stats:
@commands.command() @commands.command()
@commands.guild_only() @commands.guild_only()
@utils.custom_perms(send_messages=True) @utils.can_run(send_messages=True)
@utils.check_restricted()
async def battlestats(self, ctx, member: discord.Member = None): async def battlestats(self, ctx, member: discord.Member = None):
"""Prints the battling stats for you, or the user provided """Prints the battling stats for you, or the user provided
@ -372,8 +363,7 @@ class Stats:
await ctx.send('```\n{}```'.format(fmt)) await ctx.send('```\n{}```'.format(fmt))
@commands.command(aliases=['donators']) @commands.command(aliases=['donators'])
@utils.custom_perms(send_messages=True) @utils.can_run(send_messages=True)
@utils.check_restricted()
async def patrons(self, ctx): async def patrons(self, ctx):
"""Prints a list of all the patrons for Bonfire """Prints a list of all the patrons for Bonfire

18
cogs/tags.py
View file

@ -14,8 +14,7 @@ class Tags:
@commands.command() @commands.command()
@commands.guild_only() @commands.guild_only()
@utils.custom_perms(send_messages=True) @utils.can_run(send_messages=True)
@utils.check_restricted()
async def tags(self, ctx): async def tags(self, ctx):
"""Prints all the custom tags that this server currently has """Prints all the custom tags that this server currently has
@ -31,8 +30,7 @@ class Tags:
@commands.command() @commands.command()
@commands.guild_only() @commands.guild_only()
@utils.custom_perms(send_messages=True) @utils.can_run(send_messages=True)
@utils.check_restricted()
async def mytags(self, ctx): async def mytags(self, ctx):
"""Prints all the custom tags that this server that you own """Prints all the custom tags that this server that you own
@ -51,8 +49,7 @@ class Tags:
@commands.group(invoke_without_command=True) @commands.group(invoke_without_command=True)
@commands.guild_only() @commands.guild_only()
@utils.custom_perms(send_messages=True) @utils.can_run(send_messages=True)
@utils.check_restricted()
async def tag(self, ctx, *, tag: str): async def tag(self, ctx, *, tag: str):
"""This can be used to call custom tags """This can be used to call custom tags
The format to call a custom tag is !tag <tag> The format to call a custom tag is !tag <tag>
@ -72,8 +69,7 @@ class Tags:
@tag.command(name='add', aliases=['create', 'setup']) @tag.command(name='add', aliases=['create', 'setup'])
@commands.guild_only() @commands.guild_only()
@utils.custom_perms(send_messages=True) @utils.can_run(send_messages=True)
@utils.check_restricted()
async def add_tag(self, ctx): async def add_tag(self, ctx):
"""Use this to add a new tag that can be used in this server """Use this to add a new tag that can be used in this server
@ -152,8 +148,7 @@ class Tags:
@tag.command(name='edit') @tag.command(name='edit')
@commands.guild_only() @commands.guild_only()
@utils.custom_perms(send_messages=True) @utils.can_run(send_messages=True)
@utils.check_restricted()
async def edit_tag(self, ctx, *, tag: str): async def edit_tag(self, ctx, *, tag: str):
"""This will allow you to edit a tag that you have created """This will allow you to edit a tag that you have created
EXAMPLE: !tag edit this tag EXAMPLE: !tag edit this tag
@ -198,8 +193,7 @@ class Tags:
@tag.command(name='delete', aliases=['remove', 'stop']) @tag.command(name='delete', aliases=['remove', 'stop'])
@commands.guild_only() @commands.guild_only()
@utils.custom_perms(send_messages=True) @utils.can_run(send_messages=True)
@utils.check_restricted()
async def del_tag(self, ctx, *, tag: str): async def del_tag(self, ctx, *, tag: str):
"""Use this to remove a tag from use for this server """Use this to remove a tag from use for this server
Format to delete a tag is !tag delete <tag> Format to delete a tag is !tag delete <tag>

9
cogs/tictactoe.py
View file

@ -110,8 +110,7 @@ class TicTacToe:
@commands.group(aliases=['tic', 'tac', 'toe'], invoke_without_command=True) @commands.group(aliases=['tic', 'tac', 'toe'], invoke_without_command=True)
@commands.guild_only() @commands.guild_only()
@utils.custom_perms(send_messages=True) @utils.can_run(send_messages=True)
@utils.check_restricted()
async def tictactoe(self, ctx, *, option: str): async def tictactoe(self, ctx, *, option: str):
"""Updates the current server's tic-tac-toe board """Updates the current server's tic-tac-toe board
You obviously need to be one of the players to use this You obviously need to be one of the players to use this
@ -208,8 +207,7 @@ class TicTacToe:
@tictactoe.command(name='start', aliases=['challenge', 'create']) @tictactoe.command(name='start', aliases=['challenge', 'create'])
@commands.guild_only() @commands.guild_only()
@utils.custom_perms(send_messages=True) @utils.can_run(send_messages=True)
@utils.check_restricted()
async def start_game(self, ctx, player2: discord.Member): async def start_game(self, ctx, player2: discord.Member):
"""Starts a game of tictactoe with another player """Starts a game of tictactoe with another player
@ -244,8 +242,7 @@ class TicTacToe:
@tictactoe.command(name='delete', aliases=['stop', 'remove', 'end']) @tictactoe.command(name='delete', aliases=['stop', 'remove', 'end'])
@commands.guild_only() @commands.guild_only()
@utils.custom_perms(kick_members=True) @utils.can_run(kick_members=True)
@utils.check_restricted()
async def stop_game(self, ctx): async def stop_game(self, ctx):
"""Force stops a game of tictactoe """Force stops a game of tictactoe
This should realistically only be used in a situation like one player leaves This should realistically only be used in a situation like one player leaves

8
cogs/tutorial.py
View file

@ -10,8 +10,8 @@ class Tutorial:
self.bot = bot self.bot = bot
@commands.command() @commands.command()
@commands.check(utils.is_owner) @utils.can_run(ownership=True)
# @utils.custom_perms(send_messages=True) # @utils.can_run(send_messages=True)
async def tutorial(self, ctx, *, cmd_or_cog = None): async def tutorial(self, ctx, *, cmd_or_cog = None):
# The message we'll use to send # The message we'll use to send
output = "" output = ""
@ -110,8 +110,8 @@ class Tutorial:
inline=False inline=False
) )
try: try:
custom_perms = [func for func in command.checks if "custom_perms" in func.__qualname__][0] can_run = [func for func in command.checks if "can_run" in func.__qualname__][0]
perms = ",".join(attribute for attribute, setting in custom_perms.perms.items() if setting) perms = ",".join(attribute for attribute, setting in can_run.perms.items() if setting)
embed.set_footer(text="Permissions required: {}".format(perms)) embed.set_footer(text="Permissions required: {}".format(perms))
except IndexError: except IndexError:
pass pass

21
cogs/twitch.py
View file

@ -142,8 +142,7 @@ class Twitch:
@commands.group(invoke_without_command=True) @commands.group(invoke_without_command=True)
@commands.guild_only() @commands.guild_only()
@utils.custom_perms(send_messages=True) @utils.can_run(send_messages=True)
@utils.check_restricted()
async def twitch(self, ctx, *, member: discord.Member = None): async def twitch(self, ctx, *, member: discord.Member = None):
"""Use this command to check the twitch info of a user """Use this command to check the twitch info of a user
@ -164,8 +163,7 @@ class Twitch:
@twitch.command(name='add') @twitch.command(name='add')
@commands.guild_only() @commands.guild_only()
@utils.custom_perms(send_messages=True) @utils.can_run(send_messages=True)
@utils.check_restricted()
async def add_twitch_url(self, ctx, url: str): async def add_twitch_url(self, ctx, url: str):
"""Saves your user's twitch URL """Saves your user's twitch URL
@ -217,8 +215,7 @@ class Twitch:
@twitch.command(name='remove', aliases=['delete']) @twitch.command(name='remove', aliases=['delete'])
@commands.guild_only() @commands.guild_only()
@utils.custom_perms(send_messages=True) @utils.can_run(send_messages=True)
@utils.check_restricted()
async def remove_twitch_url(self, ctx): async def remove_twitch_url(self, ctx):
"""Removes your twitch URL """Removes your twitch URL
@ -234,8 +231,7 @@ class Twitch:
@twitch.command(name='alerts', aliases=['notifications']) @twitch.command(name='alerts', aliases=['notifications'])
@commands.guild_only() @commands.guild_only()
@utils.custom_perms(manage_guild=True) @utils.can_run(manage_guild=True)
@utils.check_restricted()
async def twitch_alerts_channel(self, ctx, channel: discord.TextChannel): async def twitch_alerts_channel(self, ctx, channel: discord.TextChannel):
"""Sets the notifications channel for twitch notifications """Sets the notifications channel for twitch notifications
@ -253,8 +249,7 @@ class Twitch:
@twitch.group(invoke_without_command=True) @twitch.group(invoke_without_command=True)
@commands.guild_only() @commands.guild_only()
@utils.custom_perms(send_messages=True) @utils.can_run(send_messages=True)
@utils.check_restricted()
async def notify(self, ctx): async def notify(self, ctx):
"""This can be used to modify notification settings for your twitch user """This can be used to modify notification settings for your twitch user
Call this command by itself to add 'this' server as one that will be notified when you on/offline Call this command by itself to add 'this' server as one that will be notified when you on/offline
@ -282,8 +277,7 @@ class Twitch:
@notify.command(name='on', aliases=['start,yes']) @notify.command(name='on', aliases=['start,yes'])
@commands.guild_only() @commands.guild_only()
@utils.custom_perms(send_messages=True) @utils.can_run(send_messages=True)
@utils.check_restricted()
async def notify_on(self, ctx): async def notify_on(self, ctx):
"""Turns twitch notifications on """Turns twitch notifications on
@ -304,8 +298,7 @@ class Twitch:
@notify.command(name='off', aliases=['stop,no']) @notify.command(name='off', aliases=['stop,no'])
@commands.guild_only() @commands.guild_only()
@utils.custom_perms(send_messages=True) @utils.can_run(send_messages=True)
@utils.check_restricted()
async def notify_off(self, ctx): async def notify_off(self, ctx):
"""Turns twitch notifications off """Turns twitch notifications off

2
cogs/utils/__init__.py
View file

@ -1,5 +1,5 @@
from .cards import Deck from .cards import Deck
from .checks import is_owner, custom_perms, db_check, should_ignore, check_restricted from .checks import can_run, db_check
from .config import * from .config import *
from .utilities import * from .utilities import *
from .images import create_banner from .images import create_banner

222
cogs/utils/checks.py
View file

@ -70,119 +70,133 @@ def is_owner(ctx):
return ctx.bot.owner.id == ctx.message.author.id return ctx.bot.owner.id == ctx.message.author.id
def should_ignore(bot, message): def should_ignore(ctx):
if message.guild is None: if ctx.message.guild is None:
return False return False
ignored = bot.db.load('server_settings', key=message.guild.id, pluck='ignored') ignored = ctx.bot.db.load('server_settings', key=ctx.message.guild.id, pluck='ignored')
if not ignored: if not ignored:
return False return False
return str(message.author.id) in ignored['members'] or str(message.channel.id) in ignored['channels'] return str(ctx.message.author.id) in ignored['members'] or str(ctx.message.channel.id) in ignored['channels']
def check_restricted(): def check_restricted(ctx):
async def predicate(ctx): # Return true if this is a private channel, we'll handle that in the registering of the command
# Return true if this is a private channel, we'll handle that in the registering of the command if type(ctx.message.channel) is discord.DMChannel:
if type(ctx.message.channel) is discord.DMChannel:
return True
# First get all the restrictions
restrictions = ctx.bot.db.load('server_settings', key=ctx.message.guild.id, pluck='restrictions') or {}
# Now lets check the "from" restrictions
for from_restriction in restrictions.get('from', []):
# Get the source and destination
# Source should ALWAYS be a command in this case
source = from_restriction.get('source')
destination = from_restriction.get('destination')
# Convert destination to the object we want
destination = await utilities.convert(ctx, destination)
# If we couldn't find the destination, just continue with other restrictions
# Also if this restriction we're checking isn't for this command
if destination is None or source != ctx.command.qualified_name:
continue
# This means that the type of restriction we have is `command from channel`
# Which means we do not want commands to be ran in this channel
if destination == ctx.message.channel:
return False
# This type is `command from Role` meaning anyone with this role can't run this command
elif destination in ctx.message.author.roles:
return False
# This is `command from Member` meaning this user specifically cannot run this command
elif destination == ctx.message.author:
return False
# If we are here, then there are no blacklists stopping this from running
# Now for the to restrictions this is a little different, we need to make a whitelist and
# see if our current channel is in this whitelist, as well as any whitelisted roles are in the author's roles
# Only if there is no whitelist, do we want to blanket return True
to_restrictions = restrictions.get('to', [])
if len(to_restrictions) == 0:
return True
# Otherwise there is a whitelist, and we need to start it
whitelisted_channels = []
whitelisted_roles = []
for to_restriction in to_restrictions:
# Get the source and destination
# Source should ALWAYS be a command in this case
source = to_restriction.get('source')
destination = to_restriction.get('destination')
# Convert destination to the object we want
destination = await utilities.convert(ctx, destination)
# If we couldn't find the destination, just continue with other restrictions
# Also if this restriction we're checking isn't for this command
if destination is None or source != ctx.command.qualified_name:
continue
# Append to our two whitelists depending on what type this is
if isinstance(destination, discord.TextChannel):
whitelisted_channels.append(destination)
elif isinstance(destination, discord.Role):
whitelisted_roles.append(destination)
if whitelisted_channels:
if ctx.channel not in whitelisted_channels:
return False
if whitelisted_roles:
if not any(x in ctx.message.author.roles for x in whitelisted_roles):
return False
# If we have passed all of these, then we are allowed to run this command
# This looks like a whole lot, but all of these lists will be very tiny in almost all cases
# And only delving deep into the specific lists that may be large, will we finally see "large" lists
# Which means this still will not be slow in other cases
return True return True
return commands.check(predicate) # First get all the restrictions
restrictions = ctx.bot.db.load('server_settings', key=ctx.message.guild.id, pluck='restrictions') or {}
# Now lets check the "from" restrictions
for from_restriction in restrictions.get('from', []):
# Get the source and destination
# Source should ALWAYS be a command in this case
source = from_restriction.get('source')
destination = from_restriction.get('destination')
# Convert destination to the object we want
destination = await utilities.convert(ctx, destination)
# If we couldn't find the destination, just continue with other restrictions
# Also if this restriction we're checking isn't for this command
if destination is None or source != ctx.command.qualified_name:
continue
# This means that the type of restriction we have is `command from channel`
# Which means we do not want commands to be ran in this channel
if destination == ctx.message.channel:
return False
# This type is `command from Role` meaning anyone with this role can't run this command
elif destination in ctx.message.author.roles:
return False
# This is `command from Member` meaning this user specifically cannot run this command
elif destination == ctx.message.author:
return False
# If we are here, then there are no blacklists stopping this from running
# Now for the to restrictions this is a little different, we need to make a whitelist and
# see if our current channel is in this whitelist, as well as any whitelisted roles are in the author's roles
# Only if there is no whitelist, do we want to blanket return True
to_restrictions = restrictions.get('to', [])
if len(to_restrictions) == 0:
return True
# Otherwise there is a whitelist, and we need to start it
whitelisted_channels = []
whitelisted_roles = []
for to_restriction in to_restrictions:
# Get the source and destination
# Source should ALWAYS be a command in this case
source = to_restriction.get('source')
destination = to_restriction.get('destination')
# Convert destination to the object we want
destination = await utilities.convert(ctx, destination)
# If we couldn't find the destination, just continue with other restrictions
# Also if this restriction we're checking isn't for this command
if destination is None or source != ctx.command.qualified_name:
continue
# Append to our two whitelists depending on what type this is
if isinstance(destination, discord.TextChannel):
whitelisted_channels.append(destination)
elif isinstance(destination, discord.Role):
whitelisted_roles.append(destination)
if whitelisted_channels:
if ctx.channel not in whitelisted_channels:
return False
if whitelisted_roles:
if not any(x in ctx.message.author.roles for x in whitelisted_roles):
return False
# If we have passed all of these, then we are allowed to run this command
# This looks like a whole lot, but all of these lists will be very tiny in almost all cases
# And only delving deep into the specific lists that may be large, will we finally see "large" lists
# Which means this still will not be slow in other cases
return True
def custom_perms(**perms): def can_run(ctx, **perms):
# Return true if this is a private channel, we'll handle that in the registering of the command
if type(ctx.message.channel) is discord.DMChannel:
return True
# Get the member permissions so that we can compare
guild_perms = ctx.message.author.guild_permissions
channel_perms = ctx.message.author.permissions_in(ctx.message.channel)
# Currently the library doesn't handle administrator overrides..so lets do this manually
if guild_perms.administrator:
return True
# Next, set the default permissions if one is not used, based on what was passed
# This will be overriden later, if we have custom permissions
required_perm = discord.Permissions.none()
for perm, setting in perms.items():
setattr(required_perm, perm, setting)
required_perm_value = ctx.bot.db.load('server_settings', key=ctx.message.guild.id, pluck='permissions') or {}
required_perm_value = required_perm_value.get(ctx.command.qualified_name)
if required_perm_value:
required_perm = discord.Permissions(required_perm_value)
# Now just check if the person running the command has these permissions
return guild_perms >= required_perm or channel_perms >= required_perm
def can_run(**kwargs):
def predicate(ctx): def predicate(ctx):
# Return true if this is a private channel, we'll handle that in the registering of the command # First check if the command requires ownership of the bot
if type(ctx.message.channel) is discord.DMChannel: if kwargs.pop("ownership", False) and not is_owner(ctx):
return True return False
# Next check if it requires any certain permissions
if kwargs and not can_run(ctx, **kwargs):
return False
# Next...check custom restrictions
if check_restricted(ctx):
return False
# Then if the user/channel should be ignored
if should_ignore(ctx):
return False
# Otherwise....we're good
return True
# Get the member permissions so that we can compare predicate.perms = kwargs
guild_perms = ctx.message.author.guild_permissions
channel_perms = ctx.message.author.permissions_in(ctx.message.channel)
# Currently the library doesn't handle administrator overrides..so lets do this manually
if guild_perms.administrator:
return True
# Next, set the default permissions if one is not used, based on what was passed
# This will be overriden later, if we have custom permissions
required_perm = discord.Permissions.none()
for perm, setting in perms.items():
setattr(required_perm, perm, setting)
required_perm_value = ctx.bot.db.load('server_settings', key=ctx.message.guild.id, pluck='permissions') or {}
required_perm_value = required_perm_value.get(ctx.command.qualified_name)
if required_perm_value:
required_perm = discord.Permissions(required_perm_value)
# Now just check if the person running the command has these permissions
return guild_perms >= required_perm or channel_perms >= required_perm
predicate.perms = perms
return commands.check(predicate) return commands.check(predicate)