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 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
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)
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)
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)}'
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
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)}'
def get_commands(self, conn: Conexao, servidor: Servidor):
"""
:param conn: Conexão com o banco de dados
:param servidor: Servidor que quer saber todos os comandos desativados
:type conn: Conexao
:type servidor: Servidor
:return: Vai retornar a lista com todos os ComandoDesativado que o servidor tem
:rtype: list
"""
cursor = conn.cursor()
try:
query = 'SELECT * FROM cmd_desativado_get_comandos(%s);' # function que está banco
cursor.execute(query, (servidor.id,))
tuple_comandos_desativados = cursor.fetchall()
list_comandos_desativados = []
for comando in tuple_comandos_desativados:
list_comandos_desativados.append(ComandoDesativado(servidor, comando[0]))
return list_comandos_desativados
except Exception as e:
return [f'error: {str(e)}']
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))
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 _testes(self, ctx):
tempo_msg = Stopwatch()
msg = await ctx.send(
'Realizando os testes <a:loading:756715436149702806>')
tempo_msg.stop()
conexao_check = False
banco_check = False
testes_check = True
testes_falhos = []
try:
tempo_conexao = Stopwatch()
conexao = Conexao()
cursor = conexao.cursor()
tempo_conexao.stop()
conexao_check = True
except:
tempo_conexao = None
conexao = None
cursor = None
try:
if conexao is not None:
query = 'select serverId from servidor;'
tempo_query = Stopwatch()
cursor.execute(query)
tempo_query.stop()
result = [c[0] for c in cursor.fetchall()]
conexao.fechar()
else:
raise Exception
except:
tempo_query = None
result = None
if result is not None:
servers = [c.id for c in self.bot.guilds]
if len(u.difference_between_lists(result, servers)) == 0:
banco_check = True
# testes das funções uteis
# [(operação, resultado esperado)]
testes = [
("u.capitalize(';;ABC')", ';;Abc'),
("u.capitalize('´ABC')", '´Abc'),
("u.capitalize('12345AB __+=12llaksamC')",
'12345Ab __+=12llaksamc'),
("u.capitalize('9Ç12Opa')", '9Ç12opa'),
("u.capitalize('12É987G654U012A!')", '12É987g654u012a!'),
("u.datetime_format(datetime(2020, 10, 21, 16, 43, 48), datetime(2020, 10, 21, 14, 42, 47))",
'Hoje há 2 horas, 1 minuto e 1 segundo.'),
("u.datetime_format(datetime(2020, 10, 21, 16, 43, 48), datetime(2020, 10, 20, 16, 23, 18))",
'Ontem há 20 minutos e 30 segundos.'),
("u.datetime_format(datetime(2020, 10, 21, 16, 43, 48), datetime(2020, 9, 10, 10, 59, 59))",
'1 mês, 11 dias e 5 horas.'),
("u.inverter_string('opa')", 'ɐdo'),
("u.inverter_string('teste1234abc')", 'ɔqɐ4321ǝʇsǝʇ'),
("u.inverter_string('áããçãóṕteste')", 'ǝʇsǝʇṕóãçããá'),
("u.is_number('123')", True),
("u.is_number('99999a')", False),
("u.is_number('3.1415')", True),
("u.is_number('3.1415a')", False),
("u.is_number('teste')", False),
("u.convert_to_bool('SIm')", True),
("u.convert_to_bool('sim')", True),
("u.convert_to_bool('1')", True),
("u.convert_to_bool('ye')", True),
("u.convert_to_bool('aTIvo')", True),
("u.convert_to_bool('on')", True),
("u.convert_to_bool('yep')", None),
("u.convert_to_bool('ava')", None),
("u.convert_to_bool('teste')", None),
("u.convert_to_bool('2')", None),
("u.convert_to_bool('+-=')", None),
("u.convert_to_bool('çç')", None),
("u.convert_to_bool('abc')", None),
("u.convert_to_bool('não')", False),
("u.convert_to_bool('nao')", False),
("u.convert_to_bool('No')", False),
("u.convert_to_bool('0')", False),
("u.convert_to_bool('faLse')", False),
("u.convert_to_bool('FALSE')", False),
("u.convert_to_bool('desaTIvo')", False),
("u.convert_to_bool('off')", False),
("u.convert_to_string(True)", 'sim'),
("u.convert_to_string(None)", 'nulo'),
("u.convert_to_string(False)", 'não'),
("u.string_similarity('a', 'a')", 1.0),
("u.string_similarity('a', 'ab')", 0.5),
("u.string_similarity('falei', 'falar')", 0.6),
("u.string_similarity('123', '456')", 0.0),
("u.get_most_similar_item('123', ['123', '234', '321', '679'])",
'123'),
("u.get_most_similar_item('234', ['123', '234', '321', '679'])",
'234'),
("u.get_most_similar_item('5679', ['1234', '2345', '3210', '5679'])",
'5679'),
("u.get_most_similar_item('9234', ['1234', '2345', '3210', '5679'])",
'1234'),
("u.get_most_similar_items('9234', ['1234', '2345', '3210', '5679'])",
['1234', '2345']),
("u.get_most_similar_items('5678', ['1234', '2345', '3210', '5679'])",
['5679']),
("u.get_most_similar_items_with_similarity('5678', ['1234', '2345', '3210', '5679'])",
[['5679', 0.75]]),
("u.get_most_similar_items_with_similarity('1243', ['1234', '2345', '3210', '5679'])",
[['1234', 0.5]]),
("u.get_most_similar_items_with_similarity('9234', ['1234', '2345', '3210', '5679'])",
[['1234', 0.75], ['2345', 0.5]]),
("u.difference_between_lists(list(range(0, 20)), list(range(0, 21)))",
[20]),
("u.difference_between_lists(['a', 'b'], ['b', 'c'])", ['a', 'c']),
]
for teste, resultado in testes:
if eval(teste) != resultado:
testes_check = False
testes_falhos.append(f'Teste com erro: ```py\n{teste}```'
f'Resultado esperado: `{resultado}`\n'
f'Resultado obtido: `{eval(teste)}`')
e = discord.Embed(title=f'Resultado dos testes!',
colour=discord.Colour(0xF5F5F5),
description='** **',
timestamp=datetime.utcnow())
e.set_footer(text=f'{ctx.author}', icon_url=ctx.author.avatar_url)
if conexao_check:
con_emoji = '<a:ativado:755774682334101615>'
desc_con = f'Tempo para abrir conexão: `{str(tempo_conexao)}`'
else:
con_emoji = '<a:desativado:755774682397147226>'
desc_con = '** **'
if banco_check:
banco_emoji = '<a:ativado:755774682334101615>'
desc_banco = f'Tempo para executar a query: `{str(tempo_query)}`'
else:
banco_emoji = '<a:desativado:755774682397147226>'
desc_banco = '** **'
if testes_check:
testes_emoji = '<a:ativado:755774682334101615>'
desc_testes = 'Todas as funções estão retornando aquilo que deveriam estar retornando!'
else:
testes_emoji = '<a:desativado:755774682397147226>'
testes_falhos = '\n'.join(testes_falhos)
desc_testes = f'{testes_falhos}'
e.add_field(name=f'Conexão com o banco: {con_emoji}',
value=desc_con,
inline=False)
e.add_field(name=f'Executar uma query no banco: {banco_emoji}',
value=desc_banco,
inline=False)
e.add_field(name=f'Funções funcionando: {testes_emoji}',
value=desc_testes,
inline=False)
e.add_field(name=f'Latências',
value=f'Tempo para enviar mensagem:\n'
f'`{str(tempo_msg)}`\n'
f'Ping do discord.py:\n'
f'`{int(self.bot.latency * 1000)}ms`',
inline=False)
await msg.edit(content='', embed=e)