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)
def create(self, conn: Conexao, servidor: Servidor):
"""
:param conn: Conexão com o banco de dados
:param servidor: Servidor que vai ser criado no banco
:type conn: Conexao
:type servidor: Servidor
:return: None
:rtype: None
"""
cursor = conn.cursor() # pega o cursor
try:
query = 'CALL server_add(%s, %s);' # query sql
# o cursor vai colocar o id do servidor no lugar do primeiro "%s"
# e o prefixo no lugar do segundos "%s" e executar a query
cursor.execute(query, (
servidor.id,
servidor.prefixo,
))
conn.salvar() # se tudo ocorrer bem, ele vai salvar as alterações
except psycopg2.IntegrityError as e:
# se tentar adicionar um item que já existe
if str(e).startswith(
'duplicate key value violates unique constraint'):
raise Exception('duplicate servidor')
else: # se acontecer outro erro:
raise Exception(e)
except Exception as e: # se acontecer outro erro:
raise Exception(e)
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 _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 _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 _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 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
def update(self, conn: Conexao, servidor: Servidor):
"""
:param conn: Conexão com o banco de dados
:param servidor: O servidor que vai ser alterado
:type conn: Conexao
:type servidor: Servidor
:return: Vai sincronizar o objeto Servidor passado, com o servidor que existir no banco
:rtype: bool
"""
cursor = conn.cursor() # pega o cursor
# se o servidor não existir no banco, vai criar ele
if not self.__existe(conn, servidor):
self.create(conn, servidor)
return True # vai retornar True, pra dizer que não houve nenhum erro
try: # se ele já existe, vai atualizar
query = 'CALL server_update(%s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s);'
# vai substituir os %s pelos valores do servidor passado, respectivamente
cursor.execute(query, (
servidor.prefixo,
servidor.channel_id_log,
servidor.mensagem_deletada,
servidor.mensagem_editada,
servidor.avatar_alterado,
servidor.nome_alterado,
servidor.tag_alterado,
servidor.nick_alterado,
servidor.role_alterado,
servidor.sugestao_de_comando,
servidor.id,
))
conn.salvar()
return True
except Exception as e:
raise Exception(str(e))
return False
def embedHelpCategory(bot: Androxus = None,
ctx: commands.Context = None,
category: str = 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
e = discord.Embed(title=f'Categoria: {bot.get_emoji_from_category(category)} {capitalize(category)}',
colour=discord.Colour(random_color()),
description='Todos os comandos que estão nesta categoria!\nPara obter mais detalhes sobre '
f'um comando, digite `{prefixo}help comando`!',
timestamp=datetime.utcnow())
e.set_author(name='Androxus',
icon_url=bot.user.avatar_url)
e.set_footer(text=f'{ctx.author}',
icon_url=ctx.author.avatar_url)
comandos = [f'``{c.name}``' for c in bot.get_commands_from_category(category)]
comandos = ', '.join(comandos)
e.add_field(name='📖 Comandos:',
value=comandos,
inline=False)
conexao.fechar()
return e
async def _remove_blacklist(self, ctx, *args):
conexao = Conexao()
if ctx.message.mentions:
user_id = ctx.message.mentions[0].id
else:
user_id = int(args[0])
BlacklistRepository().delete(conexao, user_id)
conexao.fechar()
return await ctx.send(f'Usuário perdoado! {get_emoji_dance()}')
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 _sql(self, ctx, *, query=''):
if query:
if query[-1] != ';':
query += ';'
conexao = Conexao()
cursor = conexao.cursor()
modo = 'i'
try:
cursor.execute(query)
except Exception as e:
conexao.fechar()
return await ctx.send(
f'Erro ```{str(e)}``` ao executar a query!')
if 'select' in query.lower():
modo = 's'
if modo == 'i':
conexao.salvar()
await ctx.send(
f'Query:```sql\n{query}```Executado com sucesso!')
if modo == 's':
await ctx.send(
f'Query:```sql\n{query}```Resultado:```py\n{cursor.fetchall()}```'
)
conexao.fechar()
else:
return await self.bot.send_help(ctx)
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 _blacklist(self, ctx, *args):
conexao = Conexao()
if ctx.message.mentions:
user_id = ctx.message.mentions[0].id
else:
user_id = int(args[0])
blacklisted = BlacklistRepository().get_pessoa(conexao, user_id)
conexao.fechar()
if not blacklisted[0]:
msg = f'A pessoa pode usar meus comandos! {get_emoji_dance()}'
else:
msg = f'<a:no_no:755774680325029889> Esse usuário foi banido de me usar!' + \
f'\nMotivo: `{blacklisted[1]}`\nQuando: {datetime_format(blacklisted[-1])}'
return await ctx.send(msg)
async def _ping(self, ctx):
from stopwatch import Stopwatch
stopwatch_banco = Stopwatch()
conexao = Conexao()
stopwatch_banco.stop()
conexao.fechar()
stopwatch_message = Stopwatch()
mensagem_do_bot = await ctx.send(f'Calculando ping...')
stopwatch_message.stop()
await mensagem_do_bot.edit(
content=
f'Latência da API do discord: {(self.bot.latency * 1000):.2f}ms!\n'
f'Tempo para se conectar ao banco de dados: {str(stopwatch_banco)}!\n'
f'Tempo para enviar uma mensagem: {str(stopwatch_message)}!\n'
'<a:hello:755774680949850173>')
def get_servidor(self, conn: Conexao, serverId: int):
"""
:param conn: Conexão com o banco de dados
:param serverId: Id do servidor
:type conn: Conexao
:type serverId: int
:return: Vai retornar um objeto Servidor com todas as informações que estiverem salvas no banco
:rtype: Servidor
"""
cursor = conn.cursor() # pega o cursor
try:
query = 'SELECT * FROM get_server(%s);' # select para pegar o prefixo
cursor.execute(query,
(serverId, )) # vai trocar o %s pelo id do servidor
resposta = cursor.fetchone(
) # e depois, vai pegar o resultado do select
# como o fetchone vai retornar uma tupla, vamos retornar apenas o
# primeiro valor dessa tupla
if resposta: # se vier alguma coisa:
# apenas encurtando a variavel, para que a linha do return não ficasse muito grande
r = resposta
return Servidor(serverId, r[0], r[1], r[2], r[3], r[4], r[5],
r[6], r[7], r[8], r[9])
return None # se não veio nada, retorna Nulo
except Exception as e:
raise e # se acontecer algum erro...
def delete(self, conn: Conexao, servidor: Servidor):
"""
:param conn: Conexão com o banco de dados
:param servidor: O servidor que vai ser alterado
:type conn: Conexao
:type servidor: Servidor
:return: Vai deletar o servidor e tudo que estiver atrelados a ele do banco
:rtype: bool
"""
cursor = conn.cursor() # pega o cursor
try:
query = 'CALL server_remove(%s);'
cursor.execute(query, (servidor.id, ))
conn.salvar()
return True
except Exception as e:
raise Exception(str(e))
def delete(self, conn: Conexao, informacao: str):
"""
:param conn: Conexão com o banco de dados
:param informacao: Informação que vai ser deletada
:type conn: Conexao
:type informacao: str
:return: None
:rtype: None
"""
cursor = conn.cursor()
try:
query = 'CALL info_remove(%s);'
cursor.execute(query, (informacao, ))
conn.salvar()
return True
except Exception as e:
raise Exception(str(e))
return False
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()
def delete(self, conn: Conexao, comandoDesativado: ComandoDesativado):
"""
:param conn: Conexão com o banco de dados
:param comandoDesativado: Comando desativado que vai ser removido do banco
:type conn: Conexao
:type comandoDesativado: ComandoDesativado
:return: Se conseguir remover o comando do banco, vai retornar True
:rtype: bool
"""
# se o comando não existir no banco:
if not self.__existe(conn, comandoDesativado):
# é porque ele não está desativado
raise Exception('Este comando já está ativo!')
cursor = conn.cursor()
try:
query = 'CALL cmd_desativado_remove(%s, %s);'
cursor.execute(query, (comandoDesativado.servidor.id, comandoDesativado.comando.lower(),))
conn.salvar()
return True
except Exception as e:
raise Exception(str(e))
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 _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()
def create(self, conn: Conexao, informacao: str, dado: str):
"""
:param conn: Conexão com o banco de dados
:param informacao: Informação que vai ser salva no banco
:param dado: O dado referente a informação
:type conn: Conexao
:type informacao: str
:type dado: dado
:return: Se conseguir adicionar o comando ao banco, vai retornar True
:rtype: bool
"""
cursor = conn.cursor()
try:
query = 'CALL info_add(%s, %s);' # query
cursor.execute(query, (
informacao,
dado,
))
conn.salvar()
return True # vai retornar True se tudo ocorrer bem
except:
return False
def update(self, conn: Conexao, informacao: str, dado: str):
"""
:param conn: Conexão com o banco de dados
:param informacao: Informação que vai ser atualizada
:param dado: O dado que também vai ser atualizado
:type conn: Conexao
:type informacao: str
:type dado: dado
:return: Se conseguir atualizar, vai retornar True
:rtype: bool
"""
cursor = conn.cursor()
try:
query = 'CALL info_update(%s, %s);'
cursor.execute(query, (
dado,
informacao,
))
conn.salvar()
return True
except Exception as e:
raise Exception(str(e))
return False
def create(self, conn: Conexao, comandoDesativado: ComandoDesativado):
"""
:param conn: Conexão com o banco de dados
:param comandoDesativado: Comando desativado que vai ser adicionado ao banco
:type conn: Conexao
:type comandoDesativado: ComandoDesativado
:return: Se conseguir adicionar o comando ao banco, vai retornar True
:rtype: bool
"""
cursor = conn.cursor() # pega o cursor
try:
query = 'CALL cmd_desativado_add(%s, %s);' # query
cursor.execute(query, (comandoDesativado.servidor.id, comandoDesativado.comando.lower(),))
conn.salvar() # se tudo ocorrer bem, ele vai salvar as alterações
return True # se chegar até aqui, retorna True
except psycopg2.IntegrityError as e:
# se tentar adicionar um item que já existe
if str(e).startswith('duplicate key value violates unique constraint'):
raise Exception('duplicate comando desativado')
else:
raise e
except Exception as e:
raise Exception(str(e))
return False
async def _add_blacklist(self, ctx, *args):
conexao = Conexao()
if ctx.message.mentions:
user_id = ctx.message.mentions[0].id
args = ctx.message.content.split(' ')
args.pop(0)
else:
user_id = int(args[0])
args = list(args)
args.pop(0)
arg = args
if args:
motivo = ' '.join(arg)
else:
motivo = 'nulo'
try:
BlacklistRepository().create(conexao, user_id, motivo)
conexao.fechar()
except Exception as e:
if str(e) == 'blacklisted':
return await ctx.send('Essa pessoa já está na blacklist!')
return await ctx.send(
'Este usuário não vai poder usar meus comandos! <a:banned:756138595882107002>'
f'\nCom o motivo: {motivo}')
def get_sql_version(self, conn: Conexao):
"""
:param conn: Conexão com o banco de dados
:type conn: Conexao
:return: Vai retornar a versão do banco de dados
:rtype: str
"""
cursor = conn.cursor()
try:
query = 'SELECT version()'
cursor.execute(query)
resposta = cursor.fetchone()
return resposta[0]
except Exception as e:
return f'error: {str(e)}'
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!')
def get_dado(self, conn: Conexao, informacao: str):
"""
:param conn: Conexão com o banco de dados
:param informacao: Informação que vai querer pegar o dado
:type conn: Conexao
:type informacao: str
:return: Vai retornar o dado referente a informação passada
:rtype: str
"""
cursor = conn.cursor()
try:
query = 'SELECT * FROM info_get(%s);'
cursor.execute(query, (informacao, ))
resposta = cursor.fetchone()
if resposta:
return resposta[0]
return resposta
except Exception as e:
return f'error: {str(e)}'
