async def command_disabled(ctx):
"""
Checks if a command is disabled or blocked for user.
This check will be executed before other command checks.
"""
if bot.ignoring.check_command(ctx):
raise commands.DisabledCommand()
if bot.ignoring.check_user_command(ctx.author,
ctx.command.qualified_name):
raise commands.DisabledCommand()
return True
class Questionnaire(commands.Cog):
def __init__(self, bot):
self.bot = bot
@commands.Cog.listener("on_startup")
async def on_startup(self):
if not self.bot.debug:
print("Added listeners: Questionnaire")
self.bot.add_listener(self.on_message, "on_message")
async def on_message(self, message):
async def get_prefix():
for pre in await self.bot.get_prefix(message):
if message.content.lower().startswith(pre):
return pre
return None
if message.guild is None or message.author.bot:
return None
elif (prefix := await get_prefix()) is None:
return None
args = message.content[len(prefix):].split(" ")
if len(args) > 0:
questionnaire = await self.bot.db["questionnaires"].find_one({
"server":
message.guild.id,
"command":
args[0]
})
if questionnaire:
if self.bot.has_permissions(message.channel,
send_messages=True):
if not await self.bot.is_command_enabled(
message.guild, self):
raise commands.DisabledCommand(
"This command has been disabled in this server.")
elif not await self.bot.is_channel_whitelisted(
message.guild, message.channel):
raise commands.DisabledCommand(
"Commands have been disabled in this channel.")
else:
await self.send_questionnaire(message.channel,
message.author,
questionnaire)
def getAPIKey(service: str) -> str:
if not service in apiKeys:
raise commands.DisabledCommand(
message=
'Command disabled due to missing API key. Please contact bot owner'
)
return apiKeys[service]
async def can_run(self, ctx):
"""Overwritten to also raise
:exc:`.ReactionOnlyCommand` for commands that have
:attr:`invoke_with_message <.ReactionCommand.invoke_with_message>`
set to ``False``.
Otherwise the same as :meth:`can_run() <discord.ext.commands.Command.can_run>`.
Parameters
----------
ctx: :class:`Context <discord.ext.reactioncommands.ReactionContext>`
Context to check if it can run against.
Raises
------
:class:`discord.ext.commands.CommandError`
Error for why command can't be run
Returns
-------
:class:`bool`
Whether or not the command can run.
"""
if not self.enabled:
raise commands.DisabledCommand(f'{self.name} command is disabled')
if not getattr(ctx, 'reaction_command',
False) and not self.invoke_with_message:
raise ReactionOnlyCommand(
f'{self.name} command is only usable with reactions')
return await super().can_run(ctx)
async def bot_check(self, ctx) -> bool:
if not self.exts_loaded or ctx.guild is None or ctx.author.bot:
raise GlobalCheckFail("Bot not ready.")
elif not self.has_permissions(ctx.channel, send_messages=True):
raise GlobalCheckFail("Missing `Send Messages` permission.")
elif not await self.is_command_enabled(ctx.guild, ctx.command):
raise commands.DisabledCommand(
"This command has been disabled in this server.")
elif not await self.is_channel_whitelisted(
ctx.guild, ctx.channel, command=ctx.command):
raise commands.DisabledCommand(
"Commands have been disabled in this channel.")
return True
async def _verify_checks(self, ctx):
if not self.enabled:
raise commands.DisabledCommand(f"{self.name} command is disabled")
if not (await self.can_run(ctx, change_permission_state=True)):
raise commands.CheckFailure(
f"The check functions for command {self.qualified_name} failed."
)
def bot_check(self, ctx):
if ctx.guild:
if not CogController.is_disabled(ctx.command.cog_name,
ctx.guild.id):
if not CommandController.is_disabled(
ctx.command.qualified_name, ctx.guild.id):
if not BlacklistedUsers.is_blacklisted(
ctx.author.id, ctx.guild.id):
return True
else:
raise commands.CheckFailure(
"Failed global check because user is blacklisted.")
else:
raise commands.DisabledCommand(
"This command is disabled on the server.")
else:
raise commands.DisabledCommand(
"Failed attempt to use command from a disabled module.")
else:
return True
async def can_run(self, ctx):
if not self.enabled:
raise commands.DisabledCommand(
'{0.name} command is disabled'.format(self))
original = ctx.command
ctx.command = self
try:
predicates = self.checks
if not predicates:
return True
return await discord.utils.async_all(
predicate(ctx) for predicate in predicates)
finally:
ctx.command = original
async def on_message(self, msg):
"""Will be called from on_message listener to react for custom cmds"""
# get cmd parts/args
msg_args = cmd_re.findall(msg.content)
cmd_name = msg_args[0][1].lower(
) if msg_args[0][1] else msg_args[0][0].lower()
cmd_args = msg_args[1:]
if cmd_name not in self.commands:
return
elif (self.bot.ignoring.check_command_name(cmd_name, msg.channel)
or self.bot.ignoring.check_user_command(msg.author, cmd_name)):
raise commands.DisabledCommand()
cmd_content = await self.commands[cmd_name].get_ran_formatted_text(
self.bot, msg, cmd_args)
await msg.channel.send(cmd_content)
async def can_run(self, ctx):
if not self.enabled:
raise commands.DisabledCommand(
'{0.name} command is disabled'.format(self))
original = ctx.command
ctx.command = self
try:
if not await ctx.bot.can_run(ctx):
raise commands.CheckFailure(
f'The global check functions for command {self.qualified_name} failed.'
)
cog = self.cog
# Other checks should have more priority first
if cog is not None:
local_check = commands.Cog._get_overridden_method(
cog.cog_check)
if local_check is not None:
ret = await discord.utils.maybe_coroutine(local_check, ctx)
if not ret:
return False
if not self.checks:
return await self._check_level(ctx)
checks = self._filter_out_permissions()
pred = await discord.utils.async_all(
predicate(ctx) for predicate in checks)
if pred is False:
# An important check failed...
return False
return await self._check_level(ctx)
finally:
ctx.command = original
def predicate(ctx):
for member in ctx.guild.members:
if member.id == ctx.bot.owner_id:
return True
raise commands.DisabledCommand(
f'{ctx.invoked_with} command is disabled.')
async def disabler(ctx: "Context") -> bool:
if ctx.guild == guild:
raise commands.DisabledCommand()
return True
def bot_cli(ctx):
# Because the is_admin check runs before this, we can safely assume
# that we are in a guild
if ctx.message.channel.name != CLI_CHANNEL:
raise commands.DisabledCommand()
return True
def is_channel(ctx, channel=channel_jail):
if ctx.message.channel.name == channel:
return True
else:
raise commands.DisabledCommand(f'This command is not applicable here')
async def test__on_command_error(self):
"""Unit tests for bot._on_command_error function."""
# async def _on_command_error(bot, ctx, exc)
_on_command_error = bot._on_command_error
# mauvais serveur
ctx = mock.NonCallableMock(commands.Context, guild=10)
await _on_command_error(config.bot, ctx, None)
ctx.send.assert_not_called()
# STOP
ctx = mock_discord.get_ctx()
exc = commands.CommandInvokeError(blocs.tools.CommandExit())
await _on_command_error(config.bot, ctx, exc)
ctx.assert_sent("Mission aborted")
# STOP custom message
ctx = mock_discord.get_ctx()
exc = commands.CommandInvokeError(blocs.tools.CommandExit("cust0m"))
await _on_command_error(config.bot, ctx, exc)
ctx.assert_sent("cust0m")
# BDD error - MJ
ctx = mock_discord.get_ctx()
ctx.author.top_role = mock.MagicMock(discord.Role,
__ge__=lambda s, o: True) # >= MJ
exc = commands.CommandInvokeError(bdd.SQLAlchemyError("bzzt"))
try: raise exc.original # creating traceback
except bdd.SQLAlchemyError: pass
await _on_command_error(config.bot, ctx, exc)
mock_discord.assert_sent(config.Channel.logs, "Rollback session")
config.Channel.logs.send.reset_mock()
config.session.rollback.assert_called_once()
config.session.rollback.reset_mock()
ctx.assert_sent(["Un problème est survenu", "Traceback",
"SQLAlchemyError", "bzzt"])
# BDD error - not MJ
ctx = mock_discord.get_ctx()
ctx.author.top_role = mock.MagicMock(discord.Role,
__ge__=lambda s, o: False) # < MJ
exc = commands.CommandInvokeError(bdd.DriverOperationalError("bzoozt"))
try: raise exc.original # creating traceback
except bdd.DriverOperationalError: pass
await _on_command_error(config.bot, ctx, exc)
mock_discord.assert_sent(config.Channel.logs, "Rollback session")
config.Channel.logs.send.reset_mock()
config.session.rollback.assert_called_once()
config.session.rollback.reset_mock()
ctx.assert_sent(["Un problème est survenu",
bdd.DriverOperationalError.__name__, "bzoozt"])
ctx.assert_not_sent("Traceback")
# BDD error - session not ready : on vérifie juste que pas d'erreur
ctx = mock_discord.get_ctx()
_session = config.session
del config.session
ctx.author.top_role = mock.MagicMock(discord.Role,
__ge__=lambda s, o: True) # >= MJ
exc = commands.CommandInvokeError(bdd.SQLAlchemyError("bzzt"))
await _on_command_error(config.bot, ctx, exc)
mock_discord.assert_sent(config.Channel.logs) # nothing
config.Channel.logs.send.reset_mock()
ctx.assert_sent(["Un problème est survenu", "SQLAlchemyError", "bzzt"])
config.session = _session
# CommandNotFound
ctx = mock_discord.get_ctx()
await _on_command_error(config.bot, ctx, commands.CommandNotFound())
ctx.assert_sent("je ne connais pas cette commande")
# DisabledCommand
ctx = mock_discord.get_ctx()
await _on_command_error(config.bot, ctx, commands.DisabledCommand())
ctx.assert_sent("Cette commande est désactivée")
# ConversionError
command = mock.Mock()
ctx = mock_discord.get_ctx(command)
exc = commands.ConversionError("bkrkr", "kak")
await _on_command_error(config.bot, ctx, exc)
ctx.assert_sent(["ce n'est pas comme ça qu'on utilise cette commande",
"ConversionError", "bkrkr", "kak"])
config.bot.get_context.assert_called_with(ctx.message)
self.assertEqual(ctx.message.content, f"!help {command.name}")
config.bot.get_context.return_value.reinvoke.assert_called()
# UserInputError
command = mock.Mock()
ctx = mock_discord.get_ctx(command)
exc = commands.UserInputError("bakaka")
await _on_command_error(config.bot, ctx, exc)
ctx.assert_sent(["ce n'est pas comme ça qu'on utilise cette commande",
"UserInputError", "bakaka"])
config.bot.get_context.assert_called_with(ctx.message)
self.assertEqual(ctx.message.content, f"!help {command.name}")
config.bot.get_context.return_value.reinvoke.assert_called()
# UserInputError derivate
command = mock.Mock()
ctx = mock_discord.get_ctx(command)
exc = commands.BadArgument("bakaka")
await _on_command_error(config.bot, ctx, exc)
ctx.assert_sent(["ce n'est pas comme ça qu'on utilise cette commande",
"BadArgument", "bakaka"])
config.bot.get_context.assert_called_with(ctx.message)
self.assertEqual(ctx.message.content, f"!help {command.name}")
config.bot.get_context.return_value.reinvoke.assert_called()
# CheckAnyFailure
ctx = mock_discord.get_ctx()
exc = commands.CheckAnyFailure(mock.ANY, mock.ANY)
await _on_command_error(config.bot, ctx, exc)
ctx.assert_sent("cette commande est réservée aux MJs")
# MissingAnyRole
ctx = mock_discord.get_ctx()
exc = commands.MissingAnyRole([mock.ANY])
await _on_command_error(config.bot, ctx, exc)
ctx.assert_sent("Cette commande est réservée aux joueurs")
# MissingRole
ctx = mock_discord.get_ctx()
exc = commands.MissingRole(mock.ANY)
await _on_command_error(config.bot, ctx, exc)
ctx.assert_sent("cette commande est réservée aux joueurs en vie")
# one_command.AlreadyInCommand, not addIA/modifIA
command = mock.Mock()
command.configure_mock(name="blabla")
ctx = mock_discord.get_ctx(command)
exc = blocs.one_command.AlreadyInCommand()
await _on_command_error(config.bot, ctx, exc)
ctx.assert_sent("Impossible d'utiliser une commande pendant")
# one_command.AlreadyInCommand, addIA
command = mock.Mock()
command.configure_mock(name="addIA")
ctx = mock_discord.get_ctx(command)
exc = blocs.one_command.AlreadyInCommand()
await _on_command_error(config.bot, ctx, exc)
ctx.assert_sent()
# one_command.AlreadyInCommand, modifIA
command = mock.Mock()
command.configure_mock(name="modifIA")
ctx = mock_discord.get_ctx(command)
exc = blocs.one_command.AlreadyInCommand()
await _on_command_error(config.bot, ctx, exc)
ctx.assert_sent()
# CheckFailure (autre check erreur)
ctx = mock_discord.get_ctx()
exc = commands.CheckFailure("jojo")
with mock.patch("lgrez.blocs.tools.mention_MJ") as mmj_patch:
await _on_command_error(config.bot, ctx, exc)
mmj_patch.assert_called_once_with(ctx)
ctx.assert_sent(["cette commande ne puisse pas être exécutée",
"CheckFailure", "jojo"])
# other exception
ctx = mock_discord.get_ctx()
exc = AttributeError("oh")
with mock.patch("lgrez.blocs.tools.mention_MJ") as mmj_patch:
await _on_command_error(config.bot, ctx, exc)
mmj_patch.assert_called_once_with(ctx)
ctx.assert_sent(["Une erreur inattendue est survenue",
"AttributeError", "oh"])
# other exception
ctx = mock_discord.get_ctx()
class SomeException(Exception):
pass
exc = SomeException("p!wet")
with mock.patch("lgrez.blocs.tools.mention_MJ") as mmj_patch:
await _on_command_error(config.bot, ctx, exc)
mmj_patch.assert_called_once_with(ctx)
ctx.assert_sent(["Une erreur inattendue est survenue",
"SomeException", "p!wet"])
def isEnabled(ctx):
if Storage.isEnabled(ctx.guild, 'Moderation') is False:
raise commands.DisabledCommand()
else:
return True