async def _channel_log(self, ctx, channel: discord.TextChannel = None):
if channel is not None:
conexao = Conexao()
servidor = ServidorRepository().get_servidor(conexao, ctx.guild.id)
if servidor.channel_id_log is None:
servidor.channel_id_log = channel.id
ServidorRepository().update(conexao, servidor)
conexao.fechar()
return await ctx.send(
f'{ctx.author.mention} Log ativado com sucesso em <#{channel.id}>!'
)
else:
log_antigo = servidor.channel_id_log
servidor.channel_id_log = channel.id
ServidorRepository().update(conexao, servidor)
conexao.fechar()
return await ctx.send(
f'{ctx.author.mention} Chat de logs alterado com sucesso!\n'
f'Antigo: <#{log_antigo}>\nNovo: <#{channel.id}>')
else:
conexao = Conexao()
servidor = ServidorRepository().get_servidor(conexao, ctx.guild.id)
if servidor.channel_id_log is not None:
servidor.channel_id_log = None
ServidorRepository().update(conexao, servidor)
conexao.fechar()
return await ctx.send(f'{ctx.author.mention} Log desativado!')
else:
await self.bot.send_help(ctx)
async def _reativar_sugestao(self, ctx):
conexao = Conexao()
servidor = ServidorRepository().get_servidor(conexao, ctx.guild.id)
if not servidor.sugestao_de_comando:
servidor.sugestao_de_comando = True
ServidorRepository().update(conexao, servidor)
conexao.fechar()
return await ctx.send('Sugestões reativadas!')
else:
conexao.fechar()
return await ctx.send('As sugestões já estavam ativadas!')
async def _reativar_comando(self, ctx, comando=None):
if comando is None:
return await self.bot.send_help(ctx)
conexao = Conexao()
servidor = ServidorRepository().get_servidor(conexao, ctx.guild.id)
comando_desativado = ComandoDesativado(servidor, comando)
# verificação para saber se o comando existe no banco
comandos_desativados = ComandoDesativadoRepository().get_commands(
conexao, servidor)
# se não tiver o comando no banco:
if not comando_desativado in [cmd for cmd in comandos_desativados]:
conexao.fechar()
return await ctx.send(
'<a:atencao:755844029333110815> Este comando já está ativo!')
try:
ComandoDesativadoRepository().delete(conexao, comando_desativado)
embed = discord.Embed(title=f'Comando reativado com sucesso!',
colour=discord.Colour(random_color()),
description=f'Comando reativado: {comando}',
timestamp=datetime.utcnow())
embed.set_footer(text=f'{ctx.author}',
icon_url=f'{ctx.author.avatar_url}')
return await ctx.send(content='<a:on:755774680580882562>',
embed=embed)
except Exception as e:
raise e
finally:
conexao.fechar()
async def _remover_comando(self, ctx, *, comando: str = None):
if comando is None:
return await self.bot.send_help(ctx)
conexao = Conexao()
servidor = ServidorRepository().get_servidor(conexao, ctx.guild.id)
# vai verificar se o comando está no banco
# aliás, pra remover o comando, ele precisa existir no banco
comando_personalizado = ComandoPersonalizado(servidor, comando.lower(),
'', False)
if comando_personalizado not in [
cmd for cmd in ComandoPersonalizadoRepository().get_commands(
conexao, servidor)
]:
conexao.fechar()
return await ctx.send(
'<a:atencao:755844029333110815> Este comando não existe!')
try:
ComandoPersonalizadoRepository().delete(conexao,
comando_personalizado)
embed = discord.Embed(title=f'Comando removido com sucesso!',
colour=discord.Colour(random_color()),
description=f'Comando: {comando}',
timestamp=datetime.utcnow())
embed.set_footer(text=f'{ctx.author}',
icon_url=ctx.author.avatar_url)
return await ctx.send(content=get_emoji_dance(), embed=embed)
except Exception as e:
raise e
finally:
conexao.fechar()
async def on_message_delete(self, message):
if message.author.bot: return
if not self.bot.is_ready(): return
if self.bot.maintenance_mode: return
if message.is_system(): return
if message.guild is None: return
conexao = Conexao()
server = ServidorRepository().get_servidor(conexao, message.guild.id)
conexao.fechar()
if server.channel_id_log is not None:
channel = self.bot.get_channel(server.channel_id_log)
if channel is not None:
if server.mensagem_deletada:
msg_escaped = discord.utils.escape_markdown(
message.content)
embed = discord.Embed(
title=f'Mensagem deletada',
colour=discord.Colour(random_color()),
description=f'Autor: {message.author.name}\n'
f'Menção: {message.author.mention}\n'
f'Id: {message.author.id}\n'
f'Chat: <#{message.channel.id}>\n'
f'Mensagem deletada:```{msg_escaped}```',
timestamp=datetime.utcnow())
embed.set_thumbnail(url=message.author.avatar_url)
await channel.send(embed=embed)
async def on_message_edit(self, before, after):
if after.author.bot: return
if not self.bot.is_ready(): return
if self.bot.maintenance_mode: return
if before.content == after.content: return
if after.is_system(): return
if (after.guild is None) or (before.guild is None): return
conexao = Conexao()
server = ServidorRepository().get_servidor(conexao, after.guild.id)
conexao.fechar()
if server.channel_id_log is not None:
channel = self.bot.get_channel(server.channel_id_log)
if channel is not None:
if server.mensagem_editada:
msg_antiga = discord.utils.escape_markdown(before.content)
msg_nova = discord.utils.escape_markdown(after.content)
embed = discord.Embed(
title='Mensagem editada',
colour=discord.Colour(random_color()),
description=f'Autor: {after.author.name}\n'
f'Menção: {after.author.mention}\n'
f'Id: {after.author.id}\n'
f'Chat: <#{after.channel.id}>\n'
f'Mensagem antiga:```{msg_antiga}```'
f'[Mensagem nova]({after.jump_url}):'
f'```{msg_nova}```',
timestamp=datetime.utcnow())
embed.set_thumbnail(url=after.author.avatar_url)
await channel.send(embed=embed)
async def on_guild_join(self, ctx):
# toda vez que adicionarem o bot num servidor, vai adicionar o servidor ao banco
servidor = Servidor(ctx.id)
conexao = Conexao()
try:
ServidorRepository().create(conexao, servidor)
except Exception as e:
raise e
finally:
conexao.fechar()
try:
# source: https://github.com/AlexFlipnote/discord_bot.py/blob/master/cogs/events.py#L52
to_send = sorted([chan for chan in ctx.channels if
chan.permissions_for(ctx.me).send_messages and isinstance(chan, discord.TextChannel)],
key=lambda x: x.position)[0]
except IndexError:
pass
else:
try:
adm = ''
if ctx.me.guild_permissions.view_audit_log:
async for entry in ctx.audit_logs(limit=2):
if str(entry.action).startswith('AuditLogAction.bot_add') and (
str(entry.target) == str(self.bot.user)):
adm = f' {entry.user.mention}'
await to_send.send(f'{get_emoji_dance()}\nOlá{adm}! Obrigado por me adicionar em seu servidor!\n' +
'Para saber todos os meus comandos, digite ``--cmds``!')
except:
pass
async def _change_prefix(self,
ctx,
prefixo_novo=get_configs()['default_prefix']):
conexao = Conexao()
if ctx.prefix.replace("!", "").replace(" ",
"") == self.bot.user.mention:
# vai pegar o prefixo que está no banco
prefixo_antigo = pegar_o_prefixo(self.bot, ctx, False, conexao)
else:
# se a pessoa não marcou o bot:
prefixo_antigo = ctx.prefix
servidor = Servidor(ctx.guild.id, prefixo_novo)
ServidorRepository().update(conexao, servidor)
if prefixo_novo != get_configs()['default_prefix']:
embed = discord.Embed(
title=f'Prefixo alterado com sucesso!',
colour=discord.Colour(random_color()),
description=f'Prefixo antigo: {prefixo_antigo}\n' +
f'Prefixo novo: {prefixo_novo}',
timestamp=datetime.utcnow())
embed.set_footer(text=f'{ctx.author}',
icon_url=f'{ctx.author.avatar_url}')
embed.add_field(
name=
f'Caso queria voltar para o prefixo padrão, basta digitar ``{prefixo_novo}prefixo``!'
f'\n{get_emoji_dance()}',
value='** **',
inline=False)
await ctx.send(embed=embed)
else:
await ctx.send(
f'Agora estou com o prefixo padrão! {get_emoji_dance()}')
conexao.fechar()
async def _desativar_comando(self, ctx, *, comando: str = None):
if comando is None:
await self.bot.send_help(ctx)
return
comandos_que_nao_podem_ser_desativados = [
'desativar_comando', 'disable_command', 'dc', 'reativar_comando',
'reactivate_command', 'change_prefix', 'prefixo', 'prefix'
'help', 'ajuda'
]
if comando.lower() in comandos_que_nao_podem_ser_desativados:
return await ctx.send(
'Você não pode desativar este comando! <a:no_no:755774680325029889>'
)
conexao = Conexao()
servidor = ServidorRepository().get_servidor(conexao, ctx.guild.id)
comando_desativado = ComandoDesativado(servidor, comando)
try:
ComandoDesativadoRepository().create(conexao, comando_desativado)
embed = discord.Embed(title=f'Comando desativado com sucesso!',
colour=discord.Colour(random_color()),
description=f'Comando desativado: {comando}',
timestamp=datetime.utcnow())
embed.set_footer(text=f'{ctx.author}',
icon_url=f'{ctx.author.avatar_url}')
return await ctx.send(content='<a:off:755774680660574268>',
embed=embed)
except Exception as e:
raise e
finally:
conexao.fechar()
async def on_guild_remove(self, ctx):
# toda vez que removerem o bot de um servidor, vai remover o servidor do banco
servidor = Servidor(ctx.id)
conexao = Conexao()
try:
ServidorRepository().delete(conexao, servidor)
except Exception as e:
raise e
finally:
conexao.fechar()
async def _configs(self, ctx):
conexao = Conexao()
servidor = ServidorRepository().get_servidor(conexao, ctx.guild.id)
conexao.fechar()
e = discord.Embed(title=f'Todas as configurações deste servidor!',
colour=discord.Colour(random_color()),
description='** **',
timestamp=datetime.utcnow())
e.set_footer(text=f'{ctx.author}', icon_url=f'{ctx.author.avatar_url}')
if ctx.guild.icon:
e.set_thumbnail(url=ctx.guild.icon_url)
if ctx.guild.banner:
e.set_image(url=ctx.guild.banner_url)
elif ctx.guild.splash_url:
e.set_image(url=ctx.guild.splash_url)
elif ctx.guild.discovery_splash_url:
e.set_image(url=ctx.guild.discovery_splash_url)
e.add_field(name=f'Prefixo', value=f'{servidor.prefixo}', inline=True)
if servidor.sugestao_de_comando:
sugestao_cmd = '<a:ativado:755774682334101615>'
else:
sugestao_cmd = '<a:desativado:755774682397147226>'
e.add_field(name=f'Sugestao de comando',
value=sugestao_cmd,
inline=True)
if servidor.channel_id_log is not None:
e.add_field(
name=f'Log',
value=
f'<a:ativado:755774682334101615>\nEm: <#{servidor.channel_id_log}>',
inline=True)
logs = []
if servidor.mensagem_deletada:
logs.append('``mensagem deletada``')
if servidor.mensagem_editada:
logs.append('``mensagem editada``')
if servidor.avatar_alterado:
logs.append('``avatar alterado``')
if servidor.nome_alterado:
logs.append('``nome alterado``')
if servidor.tag_alterado:
logs.append('``tag alterada``')
if servidor.nick_alterado:
logs.append('``nick alterado``')
if servidor.role_alterado:
logs.append('``cargo adicionado/removido``')
if len(logs) != 0:
e.add_field(name=f'Logs ativos',
value=capitalize(', '.join(logs)),
inline=True)
else:
e.add_field(name=f'Log',
value=f'<a:desativado:755774682397147226>',
inline=True)
await ctx.send(embed=e)
async def _cmds(self, ctx):
conexao = Conexao()
e = discord.Embed(
title='Todos os meus comandos',
colour=discord.Colour(random_color()),
description=
f'Caso você queira saber mais informações sobre um comando, '
'digite \'help comando\'',
timestamp=datetime.utcnow())
e.set_author(name='Androxus', icon_url=self.bot.user.avatar_url)
e.set_footer(text=f'{ctx.author}', icon_url=ctx.author.avatar_url)
categories = self.bot.get_all_categories()
servidor = None
if ctx.guild:
servidor = ServidorRepository().get_servidor(conexao, ctx.guild.id)
comandos_desativados = [
c.comando for c in ComandoDesativadoRepository().get_commands(
conexao, servidor)
]
for category in categories:
commands = self.bot.get_commands_from_category(category)
if len(commands) != 0:
for i in range(len(commands)):
commands[i] = f'``{commands[i]}``'
if servidor:
# vai remover todos os comandos desativados, da lista que vai aparecer na mensagem
for cmds_off in comandos_desativados:
if cmds_off in commands:
try:
commands = commands.remove(cmds_off)
except:
pass
e.add_field(
name=
f'{self.bot.get_emoji_from_category(category)} {capitalize(category)} ({len(commands)})',
value=f'{", ".join(commands)}.',
inline=False)
if servidor:
cmds_personalizados = ComandoPersonalizadoRepository(
).get_commands(conexao, servidor)
commands = []
if len(cmds_personalizados) >= 1:
for comando_personalizado in cmds_personalizados:
commands.append(f'``{comando_personalizado.comando}``')
commands.sort()
e.add_field(
name=
f'{self.bot.get_emoji_from_category("personalizado")} Comandos personalizados (são '
'comandos exclusivos deste servidor, e não precisam do prefixo)'
f'({len(commands)})',
value=f'{", ".join(commands)}.',
inline=False)
conexao.fechar()
await ctx.send(embed=e)
async def _modificar_comando(self,
ctx,
comando='',
resposta='',
in_text='t'):
in_text = convert_to_bool(in_text)
if in_text is None:
await ctx.send(
f'Valor ``{in_text}`` inválido! Os valores que eu aceito são: sim, não, yes, no, 0, 1'
)
return
if ctx.message.content.count('"') != 4:
return await ctx.send(
'Parece que você digitou o comando errado!\nVocê deve usar o comando assim:\n'
+
f'{ctx.prefix}modificar_comando **"**comando**"** **"**resposta**"**'
)
if (comando.replace(' ', '') == '') or (resposta.replace(' ', '')
== ''):
return await self.bot.send_help(ctx)
conexao = Conexao()
servidor = ServidorRepository().get_servidor(conexao, ctx.guild.id)
comando_personalizado = ComandoPersonalizado(servidor, comando.lower(),
resposta, in_text)
# vai verificar se o comando está no banco
# aliás, pra modificar o comando, ele precisa existir no banco
if comando_personalizado not in [
cmd for cmd in ComandoPersonalizadoRepository().get_commands(
conexao, servidor)
]:
conexao.fechar()
return await ctx.send(
'<a:atencao:755844029333110815> Este comando não existe!')
try:
ComandoPersonalizadoRepository().update(conexao,
comando_personalizado)
in_text_str = capitalize(convert_to_string(in_text))
embed = discord.Embed(
title=f'Comando modificado com sucesso!',
colour=discord.Colour(random_color()),
description=f'Comando: {comando}\nResposta: {resposta}\n'
f'Ignorar a posição do comando: {in_text_str}',
timestamp=datetime.utcnow())
embed.set_footer(text=f'{ctx.author}',
icon_url=ctx.author.avatar_url)
await ctx.send(content=get_emoji_dance(), embed=embed)
except Exception as e:
raise e
finally:
conexao.fechar()
async def _adicionar_comando(self,
ctx,
comando='',
resposta='',
in_text='t'):
in_text = convert_to_bool(in_text)
if in_text is None:
return await ctx.send(
f'Valor ``{in_text}`` inválido! Os valores que eu aceito são: sim, não, yes, no, 0, 1'
)
if ctx.message.content.count('"') < 4:
return await ctx.send(
'Parece que você digitou o comando errado!\nVocê deve usar o comando assim:\n'
+
f'{ctx.prefix}adicionar_comando **"**comando**"** **"**resposta**"**'
)
if (comando.replace(' ', '') == '') or (resposta.replace(' ', '')
== ''):
return await self.bot.send_help(ctx)
conexao = Conexao()
servidor = ServidorRepository().get_servidor(conexao, ctx.guild.id)
comando_personalizado = ComandoPersonalizado(servidor, comando.lower(),
resposta, in_text)
try:
ComandoPersonalizadoRepository().create(conexao,
comando_personalizado)
in_text_str = capitalize(convert_to_string(in_text))
embed = discord.Embed(title=f'Comando adicionado com sucesso!',
colour=discord.Colour(random_color()),
description='** **',
timestamp=datetime.utcnow())
embed.set_footer(text=f'{ctx.author}',
icon_url=ctx.author.avatar_url)
embed.add_field(
name=
f'Comando: {comando.lower()}\nResposta: {resposta}\nIgnorar a posição do comando: {in_text_str}',
value=f'** **',
inline=False)
await ctx.send(content=get_emoji_dance(), embed=embed)
except Exception as e:
raise e
finally:
conexao.fechar()
async def on_member_update(self, before, after):
if after.bot: return
if not self.bot.is_ready(): return
if self.bot.maintenance_mode: return
conexao = Conexao()
server = ServidorRepository().get_servidor(conexao, after.guild.id)
conexao.fechar()
if server is None:
return
if server.channel_id_log is not None:
channel = self.bot.get_channel(server.channel_id_log)
if channel is not None:
if before.nick != after.nick:
if server.nick_alterado:
embed = discord.Embed(
title='Nick alterado',
colour=discord.Colour(random_color()),
description=f'O(A) {after.name} mudou de nick!\n'
f'User: {after.mention}\n'
f'Id: {after.id}\n'
f'Nick antigo: {before.nick}\n'
f'Nick novo: {after.nick}',
timestamp=datetime.utcnow())
embed.set_thumbnail(url=str(after.avatar_url))
await channel.send(embed=embed)
if before.roles != after.roles:
if server.role_alterado:
cargos = [
f'<@&{c.id}>' for c in difference_between_lists(
before.roles, after.roles)
]
# se a pessoa ficou com mais cargos, do que ela tinha antes
if len(before.roles) < len(after.roles):
desc = None
if len(cargos) == 1:
desc = f'Novo cargo: {cargos[0]}'
elif len(cargos) > 1:
desc = 'Novos cargo: ' + ', '.join(cargos)
else: # se foi o contrário
desc = None
if len(cargos) == 1:
desc = f'Cargo removido: {cargos[0]}'
elif len(cargos) > 1:
desc = 'Cargos removidos: ' + ', '.join(cargos)
embed = discord.Embed(
title='Cargos alterados',
colour=discord.Colour(random_color()),
description=
f'O(A) {after.name} sofreu alteração nos cargos!\n'
f'User: {after.mention}\n'
f'Id: {after.id}\n'
f'{desc}',
timestamp=datetime.utcnow())
embed.set_thumbnail(url=str(after.avatar_url))
await channel.send(embed=embed)
if (before.premium_since is None) and (after.premium_since
is not None):
if server.role_alterado:
# pessoa começou a dar boost
embed = discord.Embed(
title='Novo booster',
colour=discord.Colour(0xffdcf4),
description=
f'O(A) {after.name} começou a dar boost!\n'
f'User: {after.mention}\n'
f'Id: {after.id}\n',
timestamp=datetime.utcnow())
embed.set_thumbnail(url=str(after.avatar_url))
await channel.send(embed=embed)
async def on_command_error(self, ctx, error):
# source: https://gist.github.com/EvieePy/7822af90858ef65012ea500bcecf1612
# This prevents any commands with local handlers being handled here in on_command_error.
if hasattr(ctx.command, 'on_error'):
return
# This prevents any cogs with an overwritten cog_command_error being handled here.
cog = ctx.cog
if cog:
if cog._get_overridden_method(cog.cog_command_error) is not None:
return
ignored = ()
# Allows us to check for original exceptions raised and sent to CommandInvokeError.
# If nothing is found. We keep the exception passed to on_command_error.
error = getattr(error, 'original', error)
if isinstance(error, ignored):
# Anything in ignored will return and prevent anything happening.
return
elif isinstance(error, errors.CommandNotFound):
# vai pegar toda a mensagem, depois do prefixo
comando = ctx.message.content.lower()[len(ctx.prefix):]
# se o primeiro caracter da mensagem, não for uma letra
if comando[0] not in ascii_letters:
# não vai fazer nada
return
comando = comando.split(' ')[0]
mostrar_erro = False
if ctx.guild:
conexao = Conexao()
servidor = ServidorRepository().get_servidor(
conexao, ctx.guild.id)
conexao.fechar()
if servidor.sugestao_de_comando:
mostrar_erro = True
else:
mostrar_erro = False
commands = []
for command in self.bot.get_all_commands():
if comando.lower() == command.category:
e = embedHelpCategory(self.bot, ctx, comando)
return await ctx.send(embed=e)
commands.append(command.name)
commands.append(command.category)
for alias in command.aliases:
commands.append(alias)
if mostrar_erro:
msg = f'{ctx.author.mention} <:sad:763839041095204895> eu não achei consegui ' \
f'achar o comando "{comando}".'
sugestao = get_most_similar_item(comando, commands)
if sugestao:
# se a sugestão for pelo menos 50% semelhante ao comando
if string_similarity(comando, sugestao) >= 0.6:
msg += f'\nVocê quis dizer ``{sugestao}``?'
msg += f'\nPara desativar esta mensagem, use o comando ``desativar_sugestão``'
return await ctx.send(msg, delete_after=10)
elif isinstance(error, errors.NotOwner):
return await ctx.send(
f'{ctx.author.mention} você não é meu criador <a:no_no:755774680325029889>'
)
elif isinstance(error, errors.MissingRequiredArgument):
return await self.bot.send_help(ctx)
elif isinstance(error, errors.MaxConcurrencyReached):
return await ctx.send(
f'Calma lá {ctx.author.mention}! Você só pode usar 1 comando por vez!'
)
elif isinstance(error, errors.NoPrivateMessage):
return await ctx.send(
f'{ctx.author.mention} Este comando só pode ser usado num servidor! <a:atencao:755844029333110815>'
)
elif isinstance(error, errors.MissingPermissions):
if len(error.missing_perms) == 1:
permissoes = error.missing_perms[0]
else:
permissoes = ', '.join(error.missing_perms)
return await ctx.send(
f'{ctx.author.mention} Você precisa ter permissão de ``{permissoes}`` para usar este comando!'
)
elif isinstance(error, errors.BotMissingPermissions):
if len(error.missing_perms) == 1:
permissoes = error.missing_perms[0]
else:
permissoes = ', '.join(error.missing_perms)
return await ctx.send(
f'{ctx.author.mention} Eu não posso executar este comando, pois não tenho permissão de '
+
f'``{permissoes}`` neste servidor! <a:sad:755774681008832623>')
elif isinstance(error, errors.CheckFailure):
return await ctx.send(
f'{ctx.author.mention} você não tem permissão para usar este comando!\nDigite '
+
f'`{ctx.prefix}help {ctx.command}` para ver quais permissões você precisa ter!'
)
elif isinstance(error, Forbidden):
if not permissions.can_embed(ctx):
if ctx.author.permissions_in(
ctx.message.channel).administrator:
msg = 'Por favor, me dê permissão de "inserir links", para que eu possa mostrar minhas mensagens ;-;'
else:
msg = 'Por favor, peça para um administrador do servidor me dar permissão de "inserir links",' \
' para que eu possa mostrar minhas mensagens ;-;'
return await ctx.send(msg)
if not permissions.can_upload(ctx):
if ctx.author.permissions_in(
ctx.message.channel).administrator:
msg = 'Por favor, me dê permissão de "anexar arquivos", para que eu possa funcionar corretamente ;-;'
else:
msg = 'Por favor, peça para um administrador do servidor me dar permissão de "anexar arquivos",' \
' para que eu possa funcionar corretamente ;-;'
return await ctx.send(msg)
if not permissions.can_react(ctx):
if ctx.author.permissions_in(
ctx.message.channel).administrator:
msg = 'Por favor, me dê permissão de "adicionar reações", para que eu possa funcionar corretamente ;-;'
else:
msg = 'Por favor, peça para um administrador do servidor me dar permissão de "adicionar reações",' \
' para que eu possa funcionar corretamente ;-;'
return await ctx.send(msg)
await ctx.send(
f'{ctx.author.mention} eu não tenho permissão para executar esse comando, acho que algum'
+
' administrador deve ter tirado minhas permissões! Com o comando ``invite``você consegue '
+ 'ter o link para me adicionar')
elif isinstance(error, errors.BadArgument):
if str(error).startswith('Member') and str(error).endswith(
'not found'):
return await ctx.send(
f'{ctx.author.mention} não consegui encontrar esse membro.'
)
elif str(error) == 'Esse id não está banido!':
return await ctx.send(
f'{ctx.author.mention} não consegui encontrar um membro banido, com este id: `{error.id}`.'
)
elif str(error) == 'Esse membro não está banido!':
return await ctx.send(
f'{ctx.author.mention} não consegui encontrar o membro banido `{error.member}`.'
)
elif str(error) == 'Membro mencionado não está banido!':
return await ctx.send(
f'{ctx.author.mention} não consegui encontrar o membro {error.user.mention} na lista de bans.'
)
elif isinstance(error, errors.CommandOnCooldown):
await ctx.send(
f'Calma lá {ctx.author.mention}, você está usando meus comandos muito rápido!\n'
+ f'Tente novamente em {error.retry_after:.2f} segundos.')
else:
if str(error).startswith('duplicate servidor'):
pass
elif str(error).startswith('duplicate comando desativado'):
return await ctx.send(
f'<a:atencao:755844029333110815> {ctx.author.mention} Esse comando já está desativado!'
)
elif str(error).startswith('Este comando já está ativo!'):
return await ctx.send(
f'<a:atencao:755844029333110815> {ctx.author.mention} Esse comando já está ativado!'
)
elif str(error).startswith('blacklisted'):
return await ctx.send(
f'<a:atencao:755844029333110815> {ctx.author.mention} Essa pessoa já está na blacklist!'
)
elif str(error).startswith('comando personalizado duplicado'):
return await ctx.send(
f'<a:atencao:755844029333110815> {ctx.author.mention} Esse comando já está cadastrado!'
)
else:
try:
return await ctx.send(
f'Ocorreu o erro:```py\n{error}```Na execução do comando ```{ctx.message.content}```<a:sad'
':755774681008832623>')
except:
print(
f'Ocorreu o erro: {error}\nNa execução do comando {ctx.message.content}'
)
async def _setup_logs(self, ctx):
# TODO
sr = ServidorRepository()
servidor = await sr.get_servidor(self.bot.db_connection, ctx.guild.id)
if servidor.channel_id_log is None:
return await ctx.reply(
f'Você precisa configurar um chat para os logs primeiro!'
' Use o comando ``channel_log``')
def check(message):
return message.author == ctx.author
await ctx.send(
f'{ctx.author.mention} Você quer que eu envie as mensagem deleta? (atual: '
f'{convert_to_string(servidor.mensagem_deletada)})(sim/não)')
try:
msg = await self.bot.wait_for('message', check=check, timeout=30)
except asyncio.TimeoutError:
return await ctx.send('Tempo esgotado!')
value = convert_to_bool(msg.content)
if value is None:
return await ctx.send(
f'{ctx.author.mention} Eu não sei o que é {msg.content}. Eu só aceito ``sim`` ou ``não``'
)
servidor.mensagem_deletada = value
await ctx.send(
f'{ctx.author.mention} Você quer que eu envie as mensagem editadas? (atual: '
f'{convert_to_string(servidor.mensagem_editada)})(sim/não)')
try:
msg = await self.bot.wait_for('message', check=check, timeout=30)
except asyncio.TimeoutError:
return await ctx.send('Tempo esgotado!')
value = convert_to_bool(msg.content)
if value is None:
return await ctx.send(
f'{ctx.author.mention} Eu não sei o que é {msg.content}. Eu só aceito ``sim`` ou ``não``'
)
servidor.mensagem_editada = value
await ctx.send(
f'{ctx.author.mention} Você quer que eu envie quando algum membro mudar o avatar? (atual: '
f'{convert_to_string(servidor.avatar_alterado)})(sim/não)')
try:
msg = await self.bot.wait_for('message', check=check, timeout=30)
except asyncio.TimeoutError:
return await ctx.send('Tempo esgotado!')
value = convert_to_bool(msg.content)
if value is None:
return await ctx.send(
f'{ctx.author.mention} Eu não sei o que é {msg.content}. Eu só aceito ``sim`` ou ``não``'
)
servidor.avatar_alterado = value
await ctx.send(
f'{ctx.author.mention} Você quer que eu envie quando algum membro mudar o nome? (atual: '
f'{convert_to_string(servidor.nome_alterado)})(sim/não)')
try:
msg = await self.bot.wait_for('message', check=check, timeout=30)
except asyncio.TimeoutError:
return await ctx.send('Tempo esgotado!')
value = convert_to_bool(msg.content)
if value is None:
return await ctx.send(
f'{ctx.author.mention} Eu não sei o que é {msg.content}. Eu só aceito ``sim`` ou ``não``'
)
servidor.nome_alterado = value
await ctx.send(
f'{ctx.author.mention} Você quer que eu envie quando algum membro mudar a tag? (atual: '
f'{convert_to_string(servidor.tag_alterado)})(sim/não)')
try:
msg = await self.bot.wait_for('message', check=check, timeout=30)
except asyncio.TimeoutError:
return await ctx.send('Tempo esgotado!')
value = convert_to_bool(msg.content)
if value is None:
return await ctx.send(
f'{ctx.author.mention} Eu não sei o que é {msg.content}. Eu só aceito ``sim`` ou ``não``'
)
servidor.tag_alterado = value
await ctx.send(
f'{ctx.author.mention} Você quer que eu envie quando algum membro de nick? (atual: '
f'{convert_to_string(servidor.nick_alterado)})(sim/não)')
try:
msg = await self.bot.wait_for('message', check=check, timeout=30)
except asyncio.TimeoutError:
return await ctx.send('Tempo esgotado!')
value = convert_to_bool(msg.content)
if value is None:
return await ctx.send(
f'{ctx.author.mention} Eu não sei o que é {msg.content}. Eu só aceito ``sim`` ou ``não``'
)
servidor.nick_alterado = value
await ctx.send(
f'{ctx.author.mention} Você quer que eu envie quando algum cargo, de algum membro, for alterado? (atual: '
f'{convert_to_string(servidor.role_alterado)})(sim/não)')
try:
msg = await self.bot.wait_for('message', check=check, timeout=30)
except asyncio.TimeoutError:
return await ctx.send('Tempo esgotado!')
value = convert_to_bool(msg.content)
if value is None:
return await ctx.send(
f'{ctx.author.mention} Eu não sei o que é {msg.content}. Eu só aceito ``sim`` ou ``não``'
)
servidor.role_alterado = value
await sr.update(self.bot.db_connection, servidor)
return await ctx.send(
f'{ctx.author.mention} configurações feitas com sucesso! Para você ver todas as'
' configurações, digite "configs"')
async def on_message_event(bot, message):
if not bot.is_ready():
return
try:
permissions.is_owner(message)
except discord.ext.commands.errors.NotOwner:
# se a pessoa não for dona do bot, e ele estiver em manutenção, simplesmente ignora a mensagem
if bot.maintenance_mode:
return
if message.author.id == bot.user.id:
return
if message.is_system():
return
ctx = await bot.get_context(message)
if not permissions.can_send(ctx):
# se o bot não tiver permissão para enviar mensagens:
return
stopwatch = Stopwatch()
# se a pessoa não usar um comando do bot, vai chegar None como prefixo
conexao = Conexao()
servidor = None
if message.guild:
servidor = ServidorRepository().get_servidor(conexao, message.guild.id)
if servidor:
prefixo = servidor.prefixo
else:
prefixo = ''
banido = BlacklistRepository().get_pessoa(conexao, message.author.id)[0]
if banido or message.author.bot:
stopwatch.stop()
return conexao.fechar()
if isinstance(message.channel,
discord.DMChannel): # se a mensagem foi enviada no dm
embed = discord.Embed(
title=f'O(A) {message.author} mandou mensagem no meu dm',
colour=0xfdfd96,
description=f'{message.content}',
timestamp=datetime.utcnow())
embed.set_footer(
text=f'{message.author.id}',
icon_url='https://media-exp1.licdn.com/dms/image/C510BAQHhOjPujl' +
'cgfQ/company-logo_200_200/0?e=2159024400&v=beta&t=49' +
'Ex7j5UkZroF7-uzYIxMXPCiV7dvtvMNDz3syxcLG8')
if len(message.attachments) != 0:
for attachment in message.attachments:
embed.set_image(url=attachment.url)
embed.set_thumbnail(url=message.author.avatar_url)
await bot.dm_channel_log.send(embed=embed)
if message.mention_everyone: # verifica se marcou here ou everyone
emoji = bot.get_emoji(755774680220172340) # emoji de ping pistola
await message.add_reaction(emoji) # adiciona a reação com o emoji
if servidor: # Se foi usado num server, vai ver se o comando está desativado
# aqui, vai verificar se o comando foi desativado
for comando_desativado in ComandoDesativadoRepository().get_commands(
conexao, servidor):
# aqui, estamos retirando o prefixo da mensagem, e criando uma lista com todas as palavras
palavras_formatadas = message.content.lower().replace(
prefixo, '').split(' ')
# se a primeira palavra, for diferente de '' e o comando desativado estiver nela:
if (palavras_formatadas[0] !=
'') and (comando_desativado.comando.lower()
in palavras_formatadas[0].lower()):
# se ela corresponder, a um comando que está desativado:
await message.channel.send(
'<a:no_no:755774680325029889> Este comando ' +
'foi desativado por um administrador do servidor!')
stopwatch.stop()
return conexao.fechar()
channel = message.channel
usando_comando = False
if servidor: # se a mensagem foi enviar num servidor
try:
# como tem 3 for, um dentro do outro, é mais facil força um erro, do que ir dando break em cada um
for cog in bot.cogs: # verifica se a mensagem, está chamando algum comando
# laço que vai passar por todos os comandos que o bot tem
for command in bot.get_cog(cog).get_commands():
if message.content.lower().startswith(
f'{prefixo}{command.name}'
): # Se a mensagem tiver o comando
usando_comando = True
raise Exception() # para o laço
for aliases in command.aliases: # também verifica os "sinônimos"
if message.content.lower().startswith(
f'{prefixo}{aliases}'): # se achar o comando
usando_comando = True
raise Exception() # para o laço
except Exception:
pass
if not usando_comando: # se não estiver usando um comando do bot
# vai ver se a pessoa usou algum comando personalizado
# só existem comandos personalizados em servidores, então aqui verifica se está num server
if servidor:
for comando_personalizado in ComandoPersonalizadoRepository(
).get_commands(conexao, servidor):
# se identificar o comando, na mensagem
if comando_personalizado.comando.lower(
) in message.content.lower():
enviar_mensagem = True
# se não for para ignorar a posição, vai ver se a mensagem inicia com o comando
if not comando_personalizado.in_text:
if not message.content.lower().startswith(
comando_personalizado.comando.lower()):
# se for obrigatorio que a mensagem comesse com o comando, e ela não estiver começando
enviar_mensagem = False # não vai responder
if enviar_mensagem:
stopwatch.stop()
await channel.send(
comando_personalizado.resposta.format(
tempo=str(stopwatch)))
return
if (f'<@{str(bot.user.id)}>'
== message.content) or (f'<@!{str(bot.user.id)}>'
== message.content):
await channel.send(
f'Use o comando ``{prefixo}cmds`` para obter todos os meus comandos!'
)
if permissions.can_use_external_emojis(ctx):
await channel.send('<a:hello:755774680949850173>')
conexao.fechar()
stopwatch.stop()
return
conexao.fechar()
stopwatch.stop()
await bot.process_commands(message)
async def on_user_update(self, before, after):
if after.bot: return
if not self.bot.is_ready(): return
if self.bot.maintenance_mode: return
conexao = Conexao()
servers_with_user = []
for guild in self.bot.guilds:
if guild.get_member(after.id) is not None:
servers_with_user.append(ServidorRepository().get_servidor(
conexao, guild.id))
conexao.fechar()
if len(servers_with_user) == 0:
return
if before.name != after.name:
embed = discord.Embed(
title='Nome alterado',
colour=discord.Colour(random_color()),
description=f'O(A) {after.name} mudou de nome!\n'
f'User: {after.mention}\n'
f'Id: {after.id}\n'
f'Nome antigo: {before.name}\n'
f'Nome novo: {after.name}',
timestamp=datetime.utcnow())
embed.set_thumbnail(url=after.avatar_url)
for server in servers_with_user:
if server.channel_id_log is not None:
channel = self.bot.get_channel(server.channel_id_log)
if (channel is not None) and server.nome_alterado:
await channel.send(embed=embed)
if before.discriminator != after.discriminator:
embed = discord.Embed(
title='Tag alterada',
colour=discord.Colour(random_color()),
description=f'O(A) {after.name} mudou a tag!\n'
f'User: {after.mention}\n'
f'Id: {after.id}\n'
f'Tag antiga: {before.discriminator}\n'
f'Tag nova: {after.discriminator}',
timestamp=datetime.utcnow())
embed.set_thumbnail(url=after.avatar_url)
for server in servers_with_user:
if server.channel_id_log is not None:
channel = self.bot.get_channel(server.channel_id_log)
if (channel is not None) and server.tag_alterado:
await channel.send(embed=embed)
if before.avatar_url != after.avatar_url:
url_antigo = str(before.avatar_url_as(format='webp'))
if url_antigo.find('?size=') != -1:
url_antigo = url_antigo[:url_antigo.rfind('?size=')]
url_novo = str(after.avatar_url_as(format='webp'))
async with aiohttp.ClientSession() as session:
async with session.get(url_antigo) as resp:
if resp.status == 200:
response_antigo = BytesIO(await resp.read())
else:
return
async with session.get(url_novo) as resp:
if resp.status == 200:
response_novo = BytesIO(await resp.read())
else:
return
avatar_antigo = Image.open(response_antigo).resize(
(512, 512), Image.ANTIALIAS)
avatar_novo = Image.open(response_novo).resize((512, 512),
Image.ANTIALIAS)
base = Image.new('RGBA', (1024, 512), (0, 0, 0, 0))
base.paste(avatar_antigo, (0, 0))
base.paste(avatar_novo, (512, 0))
arr = BytesIO()
base.save(arr, format='PNG')
arr.seek(0)
file = discord.File(arr, filename='avatar.png')
embed = discord.Embed(
title='Avatar alterado',
colour=discord.Colour(random_color()),
description=f'O(A) {after.name} mudou o avatar!\n'
f'User: {after.mention}\n'
f'Id: {after.id}\n'
f'[Avatar antigo]({before.avatar_url})'
f' → [avatar novo]({after.avatar_url})',
timestamp=datetime.utcnow())
embed.set_image(url='attachment://avatar.png')
for server in servers_with_user:
if server.channel_id_log is not None:
channel = self.bot.get_channel(server.channel_id_log)
if (channel is not None) and server.avatar_alterado:
await channel.send(file=file, embed=embed)
def embedHelpCommand(bot: Androxus = None,
ctx: commands.Context = None,
comando: str = None,
descricao: str = None,
parametros: list = [],
exemplos: list = [],
aliases: list = [],
perm_pessoa: str = None,
perm_bot: str = None,
cor: int = None):
conexao = Conexao()
# se a pessoa usou o comando, mencionando o bot:
if ctx.prefix.replace("!", "").replace(" ", "") == bot.user.mention:
# vai pegar o prefixo que está no banco
prefixo = pegar_o_prefixo(bot, ctx, False, conexao)
else:
# se a pessoa não marcou o bot:
prefixo = ctx.prefix
# se a cor não for passada, vai ser usada uma cor aleatória
cor_a_usar = cor or random_color()
if comando is None:
comando = ctx.command.name
if descricao is None:
descricao = ctx.command.description
# precisa fazer uma copia da lista, senão
# as alterações feitas aqui
# vão refletir no comando fora da função
if len(parametros) == 0:
parametros = ctx.command.parameters.copy()
if len(exemplos) == 0:
exemplos = ctx.command.examples.copy()
if len(aliases) == 0:
aliases = ctx.command.aliases.copy()
if perm_pessoa is None:
perm_pessoa = ctx.command.perm_user
if perm_bot is None:
perm_bot = ctx.command.perm_bot
exemplo = '\n'.join(exemplos).format(prefix=ctx.prefix,
author_mention=ctx.author.mention,
this_channel=f'<#{ctx.channel.id}>')
como_usar = f'``{prefixo}{comando}`` '
comando_esta_desativado = False
if ctx.guild is not None: # se a mensagem foi enviar de um server
servidor = ServidorRepository().get_servidor(conexao, ctx.guild.id)
cmds_desativados = ComandoDesativadoRepository().get_commands(
conexao, servidor)
# for em todos os comandos desativados
try:
for comando_desativado in cmds_desativados:
if comando in comando_desativado.comando: # vê se o comando principal, está desativado
comando_esta_desativado = True
break
for comando_alias in aliases: # vai verificar se algum "sinônimo" desse comando, está desativado
if comando_alias in comando_desativado.comando: # verifica se o comando está desativado
comando_esta_desativado = True
raise Exception()
except Exception: # foi usado raise error, para conseguir parar os dois laços
pass
if parametros: # se tiver pelo menos 1 item nos parâmetros
for c in range(
0, len(parametros)
): # vai adicionar `` antes, e depois dos parâmetros, em todos os itens
parametros[c] = f'``{parametros[c]}``'
como_usar += ' '.join(
parametros) # adiciona os parâmetros no "como_usar"
if aliases:
for c in range(
0, len(aliases)): # vai adicionar `` antes, e depois de alias
aliases[c] = f'``{prefixo}{aliases[c]}``'
if len(aliases) == 1:
alias = aliases[0]
else:
alias = ', '.join(aliases)
embed = discord.Embed(title=f'``{prefixo}{comando}``',
colour=discord.Colour(cor_a_usar),
description=descricao,
timestamp=datetime.utcnow())
embed.set_author(name='Androxus', icon_url=bot.user.avatar_url)
embed.set_footer(text=f'{ctx.author}', icon_url=ctx.author.avatar_url)
embed.add_field(name='**Como usar?**', value=como_usar, inline=False)
if parametros: # novamente, só vai entrar, se tiver pelo menos 1 item nos parâmetros
embed.add_field(
name=
'<a:atencao:755844029333110815> Tudo que estiver entre **<>** é obrigatório, e tudo que estiver '
'entre **[]** é opcional.',
value='** **',
inline=False)
embed.add_field(name='📖 Exemplo', value=exemplo, inline=False)
if aliases:
embed.add_field(name=':twisted_rightwards_arrows: Sinônimos',
value=alias,
inline=False)
if perm_pessoa or perm_bot:
requisito_p = ''
requisito_b = ''
if perm_pessoa:
requisito_p = f'Você precisa ter permissão de ``{perm_pessoa}`` para usar este comando!'
if perm_bot:
requisito_b = f'\nEu preciso ter permissão de ``{perm_bot}`` para realizar este comando!'
embed.add_field(name=':name_badge: Requisitos:',
value=f'{requisito_p}{requisito_b}',
inline=False)
if comando_esta_desativado: # se o comando estiver desativado
embed.add_field(
name=
"<a:atencao:755844029333110815> **O comando foi desativado por algum administrador do server!**",
value="**Se você usar este comando, eu não irei responder!**",
inline=False)
conexao.fechar()
return embed
def __init__(self):
self.repository = ServidorRepository()
self.con = globals()['con']
async def _help(self, ctx, *, comando=None):
e = None
# se o comando foi chamado pela pessoa assim: "help ..." e se a pessoa passou alguma coisa
# se o comando for None, vai mostrar a ajuda do comando "help" ou qualquer outro que vier no ctx
if (ctx.command.name == 'help') and (comando is not None):
# vai verificar se o que a pessoa passou não foi uma categoria
command = None
if not self.bot.is_category(comando):
command = self.bot.get_command(comando)
comandos_personalizados = []
# se não achar um comando, vai procurar nos comandos personalizados
if (command is None) and (ctx.guild is not None):
conexao = Conexao()
servidor = ServidorRepository().get_servidor(
conexao, ctx.guild.id)
comandos_personalizados = ComandoPersonalizadoRepository(
).get_commands(conexao, servidor)
conexao.fechar()
for cmd_pers in comandos_personalizados:
if cmd_pers.comando == comando:
e = discord.Embed(
title=
'<a:loop_fun:763809373046702110> Comando personalizado',
colour=discord.Colour(random_color()),
description=
f'**Este comando só existe neste servidor!**',
timestamp=datetime.utcnow())
e.set_author(
name='Androxus',
icon_url=f'{self.bot.user.avatar_url}')
e.set_footer(text=f'{ctx.author}',
icon_url=ctx.author.avatar_url)
e.add_field(
name=f'Comando: ```{cmd_pers.comando}```\n'
f'Resposta: ```{cmd_pers.resposta}```\n'
f'Ignorar posição: ```{convert_to_string(cmd_pers.in_text)}```',
value='** **',
inline=False)
return await ctx.send(embed=e)
# se achou um comando "escondido"
if (command is not None) and command.hidden:
command = None
# se o bot não achar o comando com esse nome
if command is None:
embed = discord.Embed(
title=
'Comando não encontrado <a:sad:755774681008832623>',
colour=discord.Colour(0xFF0000),
description=
f'Desculpe, mas não achei a ajuda para o comando ``{comando}``',
timestamp=datetime.utcnow())
embed.set_author(name='Androxus',
icon_url=f'{self.bot.user.avatar_url}')
embed.set_footer(text=f'{ctx.author}',
icon_url=f'{ctx.author.avatar_url}')
msg = '```ini\n[•] Veja se você não digitou algo errado'
all_commands = []
for command in self.bot.get_all_commands():
all_commands.append(command.name)
all_commands.append(command.category)
for alias in command.aliases:
all_commands.append(alias)
comando = ctx.message.content.lower()[len(ctx.prefix
):].split(' ')
if comando[0] == 'help':
comando.pop(0)
comando = comando[0]
if ctx.guild:
all_commands = all_commands + [
c.comando for c in comandos_personalizados
]
sugestao = get_most_similar_item(comando, all_commands)
# se a sugestão for pelo menos 50% semelhante ao comando
if (sugestao is not None) and (string_similarity(
comando, sugestao) >= 0.5):
msg += f'\n[•] Você quis dizer "{sugestao}"?'
embed.add_field(name='**Possiveis soluções:**',
value=f'{msg}```',
inline=False)
return await ctx.send(embed=embed)
else:
# se a pessoa usou o comando "help diversão" vai mostrar todos os comandos
# que estão nessa categoria
e = embedHelpCategory(self.bot, ctx, comando)
# se não passou pelo return , vai atribuir o comando ao ctx.command
ctx.command = command
# o help do comando money é diferente, por isso esta condição
if (ctx.command is not None) and (ctx.command.name == 'money'):
embed1 = embedHelpCommand(self.bot, ctx)
embed1.add_field(
name=
f'Para saber todas as abreviações das moedas que eu aceito, clique em ➡',
value=f'** **',
inline=True)
embed2 = discord.Embed(
title=f'Todas as moedas que eu aceito no comando "money"',
colour=discord.Colour(random_color()),
description='** **',
timestamp=datetime.utcnow())
translator = Translator()
moedas = ''
for c in currency_exchange.currencies():
moedas += f'{c}\n'
moedas = translator.translate(moedas, dest='pt').text
for c in moedas.splitlines():
abreviacao, moeda = c.split(' - ')
embed2.add_field(name=f'**{abreviacao}**',
value=f'{moeda}',
inline=True)
async def menu_help(ctx, msg):
# fica verificando a pagina 1, para ver se é para ir para a pagina 2
def check_page1(reaction, user, msg):
return (user.id == ctx.author.id) and (str(
reaction.emoji) == '➡') and (msg
== reaction.message)
# fica verificando a pagina 2, para ver se é para ir para a pagina 1
def check_page2(reaction, user, msg):
return (user.id == ctx.author.id) and (str(
reaction.emoji) == '⬅') and (msg
== reaction.message)
async def check_reactions_without_perm(ctx, msg, bot):
# mudas as páginas, se o bot não tiver perm pra apagar reações
while True:
while True:
reaction, user = await bot.wait_for(
'reaction_add', timeout=900.0)
if check_page1(reaction, user, msg):
break
await msg.delete()
msg = await ctx.send(embed=embed2)
await msg.add_reaction('⬅')
while True:
reaction, user = await bot.wait_for(
'reaction_add', timeout=900.0)
if check_page2(reaction, user, msg):
break
await msg.delete()
msg = await ctx.send(embed=embed1)
await msg.add_reaction('➡')
async def check_reactions_with_perm(msg, bot):
# mudas as páginas, se o bot tiver perm pra apagar reações
while True:
while True:
reaction, user = await bot.wait_for(
'reaction_add', timeout=900.0)
if check_page1(reaction, user, msg):
break
await msg.clear_reactions()
await msg.add_reaction('⬅')
await msg.edit(embed=embed2)
while True:
reaction, user = await bot.wait_for(
'reaction_add', timeout=900.0)
if check_page2(reaction, user, msg):
break
await msg.clear_reactions()
await msg.add_reaction('➡')
await msg.edit(embed=embed1)
# se foi usado num servidor:
if ctx.guild:
# se o bot tiver perm pra usar o "clear_reactions"
if ctx.guild.me.guild_permissions.manage_messages:
await check_reactions_with_perm(msg, self.bot)
else: # se o bot não tiver permissão:
await check_reactions_without_perm(
ctx, msg, self.bot)
else: # se não for usado no servidor:
await check_reactions_without_perm(ctx, msg, self.bot)
msg_bot = await ctx.send(embed=embed1)
await msg_bot.add_reaction('➡')
try:
# vai fica 1 minuto e meio esperando o usuário apertas nas reações
await asyncio.wait_for(menu_help(ctx, msg_bot),
timeout=90.0)
except asyncio.TimeoutError: # se acabar o tempo
pass
return
if e is None:
e = embedHelpCommand(self.bot, ctx)
return await ctx.send(embed=e)