def __init__(self):
Logger.__init__(self)
self.loginController = LoginController()
self.fileController = FileController(self.destinationPath)
self.ftpController = None
self.connected = False
self.observers = [Login.Login(self)]
self.user = None
def __init__(self, controller, *args, **kwargs):
Logger.__init__(self)
QWidget.__init__(self, *args, **kwargs)
self.controller = controller
self.initUI()
self.update_list()
def __init__(self, controller, *args, **kwargs):
Logger.__init__(self)
QWidget.__init__(self, *args, **kwargs)
self.controller = controller
self.setAcceptDrops(True)
self.initUI()
self.notify()
def __init__(self, url: str, login: str = None, password: str = None):
Logger.__init__(self)
self.url = url
self.login = login
self.password = password
self.startPoint = "/"
if not login:
self.ftpSession = FTP(url)
else:
self.ftpSession = FTP(url, login, password)
print(self.ftpSession)
self.ftpSession.login()
def __init__(self): # Construtora:
self.log = Logger('UsuarioRepositorio')
self.criador_conexao = CriadorConexao()
class UsuarioRepositorio:
def __init__(self): # Construtora:
self.log = Logger('UsuarioRepositorio')
self.criador_conexao = CriadorConexao()
def salvar(self, usuario):
try:
self.log.info('Criando o usuario: ' + usuario.nome)
executor = self.criador_conexao.criar_executor()
sql = "INSERT INTO usuario " \
"(data_insercao, data_alteracao, nome, email, senha, provedor, pontos) " \
"VALUES (%s, %s, %s, %s, %s, %s, %s)"
parametros = (usuario.data_insercao, usuario.data_alteracao,
usuario.nome, usuario.email, usuario.senha,
usuario.provedor, usuario.pontos)
executor.execute(sql, parametros)
self.criador_conexao.commit_mudancas()
self.criador_conexao.fechar_executor()
id_criacao = str(executor.lastrowid)
self.log.info('Criado o usuario ID: ' + id_criacao)
return id_criacao
except Exception as erro:
self.log.erro('Erro ao inserir usuario', erro)
return str(erro)
def validar(self, nome, senha):
try:
self.log.info('Validando usuario ' + nome)
executor = self.criador_conexao.criar_executor()
sql = "SELECT count(*) " \
"FROM usuario " \
"WHERE nome = %s " \
"AND senha = %s "
parametros = (nome, senha)
executor.execute(sql, parametros)
resultado = executor.fetchone()
self.criador_conexao.fechar_executor()
self.log.info('Usuario ' + nome + ' validado: ' +
str(resultado[0] == 1))
return resultado[0] == 1
except Exception as erro:
self.log.erro('Erro ao validar usuario', erro)
return str(erro)
def buscar_por_id(self, usuario_id):
try:
self.log.info('Buscando usuario ID: ' + str(usuario_id))
executor = self.criador_conexao.criar_executor()
sql = "SELECT * " \
"FROM usuario " \
"WHERE id = %s "
executor.execute(sql, (usuario_id, ))
resultado = executor.fetchone()
self.criador_conexao.fechar_executor()
return resultado
except Exception as erro:
self.log.erro('Erro ao buscar usuario ID: ' + str(usuario_id),
erro)
return None
def buscar_por_nome_usuario(self, nome_usuario):
try:
self.log.info('Buscando usuario name: ' + str(nome_usuario))
executor = self.criador_conexao.criar_executor()
sql = "SELECT * " \
"FROM usuario " \
"WHERE nome = %s"
executor.execute(sql, (nome_usuario, ))
resultado = executor.fetchone()
self.criador_conexao.fechar_executor()
return resultado
except Exception as erro:
self.log.erro('Erro ao buscar usuario name: ' + str(nome_usuario),
erro)
return None
def editar(self, usuario):
try:
self.log.info('Editando o usuario: ' + usuario.nome)
executor = self.criador_conexao.criar_executor()
sql = "UPDATE usuario SET " \
"nome = %s," \
"email = %s," \
"data_alteracao = sysdate()" \
"WHERE id = %s"
parametros = (usuario.nome, usuario.email, usuario.id)
executor.execute(sql, parametros)
self.criador_conexao.commit_mudancas()
self.criador_conexao.fechar_executor()
self.log.info('Editado o usuario ID: ' + str(usuario.id))
return str(usuario.id)
except Exception as erro:
self.log.erro('Erro ao editar o usuario', erro)
return str(0)
def validar_email(self, email):
try:
self.log.info('Validando email ' + email)
executor = self.criador_conexao.criar_executor()
sql = "SELECT count(*) " \
"FROM usuario " \
"WHERE email = %s "
parametros = (email, )
executor.execute(sql, parametros)
resultado = executor.fetchone()
self.criador_conexao.fechar_executor()
self.log.info('Email ' + email + ' validado: ' +
str(resultado[0] == 1))
return resultado[0] == 1
except Exception as erro:
self.log.erro('Erro ao validar email', erro)
return str(erro)
import json
from src.Repositorio.PostagemRepositorio import PostagemRepositorio
from src.Utils import TipoPostagemEnum, SituacaoPostagemEnum
from src.Entidades.Postagem import Postagem
from src.Utils.Logger import Logger
from src.Servico import NotificacaoServico, UsuarioServico
log = Logger('PostagemServico')
def buscar_postagem_json(postagem_id):
postagem = buscar_postagem_por_id(postagem_id)
postagem_json = postagem.json()
postagem_json['nomeAutor'] = UsuarioServico.buscar_nome_usuario_por_id(
postagem.usuario_id)
return postagem_json
def buscar_postagem_por_id(postagem_id):
postagem_repositorio = PostagemRepositorio()
tupla = postagem_repositorio.buscar_por_id(postagem_id)
postagem = Postagem()
postagem.definir_por_tupla(tupla)
return postagem
def buscar_respostas_de_postagem(postagem_id):
postagem_repositorio = PostagemRepositorio()
tuplas = postagem_repositorio.buscar_respostas_a_postagem(postagem_id)
lista_respostas = __lista_tuplas_para_lista_json(tuplas)
def __init__(self): # Construtora:
self.log = Logger('EcoPostagemRepositorio')
self.criador_conexao = CriadorConexao()
class EcoPostagemRepositorio:
def __init__(self): # Construtora:
self.log = Logger('EcoPostagemRepositorio')
self.criador_conexao = CriadorConexao()
def buscar(self, usuario_id, postagem_id):
try:
self.log.info('Buscando ecos de postagem ' + str(postagem_id) + ' de usuário ' + str(usuario_id))
executor = self.criador_conexao.criar_executor()
sql = "SELECT * " \
"FROM ecos_postagem " \
"WHERE usuario_id = %s " \
"AND postagem_id = %s"
parametros = (usuario_id, postagem_id)
executor.execute(sql, parametros)
tupla = executor.fetchone()
return tupla
except Exception as erro:
self.log.erro('Erro ao buscar ecos de usuário ' + str(usuario_id)
+ ' para postagem ' + str(postagem_id), erro)
return None
def salvar(self, eco):
try:
self.log.info('Inserindo notificação')
executor_notificacao = self.criador_conexao.criar_executor()
sql = "INSERT INTO ecos_postagem" \
"(data_insercao, data_alteracao," \
"usuario_id, postagem_id) " \
"VALUES (%s, %s, %s, %s)"
parametros = (
eco.data_insercao,
eco.data_alteracao,
eco.usuario_id,
eco.postagem_id
)
executor_notificacao.execute(sql, parametros)
self.criador_conexao.commit_mudancas()
self.criador_conexao.fechar_executor()
id_eco = str(executor_notificacao.lastrowid)
self.log.info('Criado o eco ID: ' + id_eco)
except Exception as erro:
self.log.erro('Erro ao inserir eco de usuario ' + str(eco.usuario_id) +
' em postagem ' + str(eco.postagem_id), erro)
return str(0)
def remover(self, eco):
try:
self.log.info('Removendo eco de Usuario ' + str(eco.usuario_id)
+ " na postagem " + str(eco.postagem_id))
executor = self.criador_conexao.criar_executor()
sql = "DELETE FROM ecos_postagem " \
"WHERE (usuario_id = %s) " \
" AND (postagem_id = %s) "
parametros = (
eco.usuario_id,
eco.postagem_id
)
executor.execute(sql, parametros)
self.criador_conexao.commit_mudancas()
self.criador_conexao.fechar_executor()
self.log.info('Eco de Usuario ' + str(eco.usuario_id)
+ " na postagem " + str(eco.postagem_id) + " Removido com sucesso")
return True
except Exception as erro:
self.log.erro('Falha de Usuario ' + str(eco.usuario_id) + " ao remover eco da postagem "
+ str(eco.postagem_id), erro)
return False
def buscar_por_postagem_id(self, postagem_id):
try:
self.log.info('Buscando ecos de postagem ' + str(postagem_id))
executor = self.criador_conexao.criar_executor()
sql = "SELECT * " \
"FROM ecos_postagem " \
"WHERE postagem_id = %s "
executor.execute(sql, (postagem_id,))
tuplas = executor.fetchall()
return tuplas
except Exception as erro:
self.log.erro('Erro ao buscar ecos para postagem ' + str(postagem_id), erro)
return None
def __init__(self):
self.log = Logger('CurtidasRepositorio')
self.criador_conexao = CriadorConexao()
class CurtidasRepositorio:
def __init__(self):
self.log = Logger('CurtidasRepositorio')
self.criador_conexao = CriadorConexao()
def criar(self, curtida):
try:
self.log.info('Inserindo novo registro de curtida')
executor = self.criador_conexao.criar_executor()
sql = "INSERT INTO curtidas" \
"(data_insercao, data_alteracao," \
"usuario_id, postagem_id, operacao) " \
"VALUES (%s, %s, %s, %s, %s)"
parametros = (
datetime.datetime.now(),
datetime.datetime.now(),
curtida.usuario_id,
curtida.postagem_id,
curtida.operacao
)
executor.execute(sql, parametros)
self.criador_conexao.commit_mudancas()
self.criador_conexao.fechar_executor()
id_criacao = str(executor.lastrowid)
self.log.info('Usuario ' + str(curtida.usuario_id) + " curtiu a postagem " + str(curtida.postagem_id))
return id_criacao
except Exception as erro:
self.log.erro('Falha de Usuario ' + str(curtida.usuario_id)
+ " ao curtir a postagem " + str(curtida.postagem_id), erro)
return str(0)
def remover(self, curtida):
try:
self.log.info('Removendo curtida de Usuario ' + str(curtida.usuario_id)
+ " na postagem " + str(curtida.postagem_id))
executor = self.criador_conexao.criar_executor()
sql = "DELETE FROM curtidas " \
"WHERE (usuario_id = %s) " \
" AND (postagem_id = %s) "
parametros = (
curtida.usuario_id,
curtida.postagem_id
)
executor.execute(sql, parametros)
self.criador_conexao.commit_mudancas()
self.criador_conexao.fechar_executor()
self.log.info('Curtida de Usuario ' + str(curtida.usuario_id)
+ " na postagem " + str(curtida.postagem_id) + " Removida com sucesso")
return True
except Exception as erro:
self.log.erro('Falha de Usuario ' + str(curtida.usuario_id) + " ao curtir a postagem "
+ str(curtida.postagem_id), erro)
return False
def buscar(self, usuario_id, postagem_id):
try:
self.log.info('Buscand0 curtida de usuario ' + str(usuario_id) + " em postagem " + str(postagem_id))
executor = self.criador_conexao.criar_executor()
sql = "SELECT * FROM curtidas WHERE" \
"(usuario_id = %s) AND (postagem_id = %s)"
parametros = (
usuario_id,
postagem_id
)
executor.execute(sql, parametros)
tupla = executor.fetchone()
self.criador_conexao.fechar_executor()
return tupla
except Exception as erro:
self.log.erro('Erro ao buscar a postagem ID: ' + str(postagem_id), erro)
return None
def __init__(self, path: str):
Logger.__init__(self)
self.destinationPath = path
def __init__(self, path: str):
Logger.__init__(self)
self.init = DbHelper.check_file(path)
self.database = DbHelper(path)
class PostagemRepositorio:
def __init__(self): # Construtora:
self.criador_conexao = CriadorConexao()
self.log = Logger('PostagemRepositorio')
def criar(self, postagem):
try:
self.log.info('Inserindo nova postagem')
executor = self.criador_conexao.criar_executor()
sql = "INSERT INTO postagem" \
"(data_insercao, data_alteracao," \
"titulo, conteudo, tipo, situacao," \
"postagem_respondida_id, usuario_id, curtidas) " \
"VALUES (%s, %s, %s, %s, %s, %s, %s, %s, %s)"
parametros = (postagem.data_insercao, postagem.data_alteracao,
postagem.titulo, postagem.conteudo, postagem.tipo,
postagem.situacao, postagem.postagem_respondida_id,
postagem.usuario_id, postagem.curtidas)
executor.execute(sql, parametros)
self.criador_conexao.commit_mudancas()
self.criador_conexao.fechar_executor()
id_criacao = str(executor.lastrowid)
self.log.info('Criada a postagem ID: ' + id_criacao)
return id_criacao
except Exception as erro:
self.log.erro('Erro ao inserir postagem', erro)
return str(0)
def atualizar(self, postagem):
try:
self.log.info('Atualizando postagem ID: ' + str(postagem.id))
executor = self.criador_conexao.criar_executor()
sql = "UPDATE postagem SET " \
"data_alteracao = %s, " \
"titulo = %s, conteudo = %s, tipo = %s, situacao = %s," \
"curtidas = %s, relevancia = %s, " \
"postagem_respondida_id = %s, usuario_id = %s " \
"WHERE id = %s"
parametros = (postagem.data_alteracao, postagem.titulo,
postagem.conteudo, postagem.tipo, postagem.situacao,
postagem.curtidas, postagem.relevancia,
postagem.postagem_respondida_id, postagem.usuario_id,
postagem.id)
executor.execute(sql, parametros)
self.criador_conexao.commit_mudancas()
self.criador_conexao.fechar_executor()
self.log.info('Atualizada a postagem ID: ' + str(postagem.id))
return str(postagem.id)
except Exception as erro:
self.log.erro('Erro ao atualizar postagem ID: ' + str(postagem.id),
erro)
return str(0)
def buscar_por_id(self, postagem_id):
try:
self.log.info('Buscando a postagem ID: ' + str(postagem_id))
executor = self.criador_conexao.criar_executor()
sql = "SELECT * FROM postagem WHERE" \
"(id = %s) "
executor.execute(sql, (postagem_id, ))
tupla = executor.fetchone()
self.criador_conexao.fechar_executor()
return tupla
except Exception as erro:
self.log.erro('Erro ao buscar a postagem ID: ' + str(postagem_id),
erro)
return None
def buscar(self):
try:
self.log.info('Buscando todas as postagem')
executor = self.criador_conexao.criar_executor()
sql = "SELECT * FROM postagem " \
"WHERE (tipo = '" + TipoPostagemEnum.PERGUNTA + "') " \
"ORDER BY relevancia DESC, data_insercao DESC"
executor.execute(sql)
tupla = executor.fetchall()
self.criador_conexao.fechar_executor()
return tupla
except Exception as erro:
self.log.erro('Erro ao buscar as postagem', erro)
return None
def pesquisar_postagens_por_texto(self, texto_pesquisa):
try:
self.log.info('Buscando posts com a mensagem \'' + texto_pesquisa +
'\'')
executor = self.criador_conexao.criar_executor()
sql = "SELECT * FROM postagem WHERE " \
"(tipo = '" + TipoPostagemEnum.PERGUNTA + "') AND (" \
"(titulo like '%" + texto_pesquisa + "%') OR " \
"(conteudo like '%" + texto_pesquisa + "%') OR " \
"(tipo like '%" + texto_pesquisa + "%') " \
")" \
"ORDER BY relevancia DESC "
executor.execute(sql)
tuplas = executor.fetchall()
self.criador_conexao.fechar_executor()
self.log.info('Encontrados ' + str(len(tuplas)) + ' resultados')
return tuplas
except Exception as erro:
self.log.erro('Erro ao buscar postagem', erro)
return str('ERRO: ' + str(erro))
def buscar_respostas_a_postagem(self, postagem_id):
try:
self.log.info('Buscando respostas ao post ID: ' + str(postagem_id))
executor = self.criador_conexao.criar_executor()
sql = "SELECT * FROM postagem WHERE (" \
"(postagem_respondida_id = %s ) AND " \
"(tipo = '" + TipoPostagemEnum.RESPOSTA + "')" \
")" \
"ORDER BY relevancia DESC "
executor.execute(sql, (postagem_id, ))
tuplas = executor.fetchall()
self.criador_conexao.fechar_executor()
self.log.info('Encontrados ' + str(len(tuplas)) + ' resultados')
return tuplas
except Exception as erro:
self.log.erro(
'Erro ao buscar respostas da postagem ID: ' + str(postagem_id),
erro)
return str('ERRO: ' + str(erro))
def buscar_perguntas_de_usuario(self, usuario_id):
try:
self.log.info('Buscando perguntas do usuario ID: ' +
str(usuario_id))
executor = self.criador_conexao.criar_executor()
sql = "SELECT * FROM postagem WHERE (" \
"(usuario_id = %s ) AND " \
"(tipo = '" + TipoPostagemEnum.PERGUNTA + "')" \
")" \
"ORDER BY relevancia DESC "
executor.execute(sql, (usuario_id, ))
tuplas_perguntas = executor.fetchall()
self.criador_conexao.fechar_executor()
self.log.info('Encontrados ' + str(len(tuplas_perguntas)) +
' resultados')
return tuplas_perguntas
except Exception as erro:
self.log.erro(
'Erro ao buscar perguntas do usuario ID: ' + str(usuario_id),
erro)
return str('ERRO: ' + str(erro))
def buscar_respostas_de_usuario(self, usuario_id):
try:
self.log.info('Buscando respostas do usuario ID: ' +
str(usuario_id))
executor = self.criador_conexao.criar_executor()
sql = "SELECT * FROM postagem WHERE (" \
"(usuario_id = %s ) AND " \
"(tipo = '" + TipoPostagemEnum.RESPOSTA + "')" \
")" \
"ORDER BY relevancia DESC "
executor.execute(sql, (usuario_id, ))
tuplas_respostas = executor.fetchall()
self.criador_conexao.fechar_executor()
self.log.info('Encontrados ' + str(len(tuplas_respostas)) +
' resultados')
return tuplas_respostas
except Exception as erro:
self.log.erro(
'Erro ao buscar respostas do usuario ID: ' + str(usuario_id),
erro)
return str('ERRO: ' + str(erro))
def buscar_total_respostas(self, id_postagem):
try:
self.log.info('Buscando total de respostas da postagem ' +
str(id_postagem))
executor_total_postagem = CriadorConexao.criar_executor()
sql = "SELECT count(*) " \
"FROM postagem " \
"WHERE postagem_respondida_id = %s "
executor_total_postagem.execute(sql, (id_postagem, ))
tupla_total_postagem = executor_total_postagem.fetchone()
CriadorConexao.fechar_executor()
self.log.info(
str(tupla_total_postagem[0]) + ' respostas para a postagem ' +
str(id_postagem))
return str(tupla_total_postagem[0])
except Exception as erro:
self.log.erro(
'Erro ao buscar o total de respostas da postagem ' +
str(id_postagem), erro)
return str(0)
def __init__(self):
Logger.__init__(self)
self.dao = UserDAO()