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)}'