def authenticateUser(self, EMAIL, PASSWORD):
try:
q = ctx.session.query(
ctx.mapUser.ID_USER, ctx.mapUser.EMAIL,
ctx.mapUser.PASSWORD1).filter(ctx.mapUser.EMAIL == EMAIL)
if not ctx.session.query(q.exists()).scalar():
return -1
resultCheck = {}
for item in q.all():
resultCheck = {
"password": check_password_hash(item[2], PASSWORD),
"email": item[1],
"idUsuario": item[0]
}
if not resultCheck['password']:
return -2
self.__keep = authentication.encode_auth_token(
resultCheck['idUsuario']).decode()
self.__idUser = resultCheck['idUsuario']
self.__email = resultCheck['email']
return (self.__keep, self.__email, self.__idUser)
except Exception as ex:
trace = traceback.format_exc()
self.__loggerMySQL.testInsertLog(ex.args[0], kindOfLog.ERROR(),
trace)
return -3
def chartPeopleByEvents(self, fromDate):
try:
table = ctx.mapEvento
query = ctx.session.query(
table.ID_EVENTO, table.TITULO_EVENTO, table.DATA_EVENTO
).filter(
table.DATA_EVENTO >= datetime.strptime(fromDate, '%d/%m/%Y'))
tableCredenciamento = ctx.mapCredenciamento
tableConvidado = ctx.mapConvidado
retorno = "['Evento', 'Presentes', 'Ausentes', { role: 'annotation' }]"
for item in query.all():
presentes = ctx.session.query(
tableCredenciamento.ID_EVENTO).filter(
tableCredenciamento.ID_EVENTO ==
item.ID_EVENTO).count()
ausentes = ctx.session.query(tableConvidado.ID_EVENTO).filter(
tableConvidado.ID_EVENTO ==
item.ID_EVENTO).count() - presentes
retorno += ",[{}, {}, {}, '']".format(
"'" + item.TITULO_EVENTO + "'", str(presentes),
str(ausentes))
self.__dataChart = "[{}]".format(retorno)
return True
except Exception as ex:
self.__loggerMySQL.insertLog(ex.args[0], kindOfLog.ERROR(),
traceback.format_exc())
return False
def adicionaPresenca(self, ID_EVENTO, ID_CONVIDADO):
try:
table = ctx.mapCredenciamento
q = ctx.session.query(table).filter(
table.ID_CONVIDADO == ID_CONVIDADO
and table.ID_EVENTO == ID_EVENTO)
if not ctx.session.query(q.exists()).scalar():
cmd = ctx.tb_credenciamento.insert().values(
DATA_HORA=datetime.now(),
ID_EVENTO=ID_EVENTO,
ID_CONVIDADO=ID_CONVIDADO,
PRESENTE=1)
ctx.session.execute(cmd)
ctx.session.commit()
return True
except Exception as ex:
self.__loggerMySQL.testInsertLog(ex.args[0], kindOfLog.ERROR(),
traceback.format_exc())
return False
def testListComboEvento(self, DATA):
try:
self.assertTrue(self.listComboEvento(DATA))
return self.qBase.toJsonRoute(self.__listOf, 200)
except AssertionError as ae:
_error = ae.args[0]
_message = f"There is a problem to load Event combo data. Look at the logs {_error}"
self.__loggerMySQL.testInsertLog(_message, kindOfLog.ERROR(),
traceback.format_exc())
return self.qBase.toJsonRoute(_message, 500)
def saveEvento(self, evento=mapEvento, convidado=mapConvidado):
try:
cmd = None
if evento.ID_EVENTO > 0:
cmd = ctx.tb_evento.update().values(
DATA_EVENTO=evento.DATA_EVENTO,
TITULO_EVENTO=evento.TITULO_EVENTO.upper(),
ID_EMPRESA=evento.ID_EMPRESA,
OBSERVACAO=evento.OBSERVACAO).where(
ctx.mapEvento.ID_EVENTO == evento.ID_EVENTO)
ctx.session.execute(cmd)
elif evento.ID_EVENTO == 0:
cmd = ctx.tb_evento.insert().values(
DATA_EVENTO=evento.DATA_EVENTO,
TITULO_EVENTO=evento.TITULO_EVENTO.upper(),
ID_EMPRESA=evento.ID_EMPRESA,
OBSERVACAO=evento.OBSERVACAO)
inserted = ctx.session.execute(cmd)
evento.ID_EVENTO = inserted.inserted_primary_key[0]
if len(convidado.NOME_CONVIDADO) > 0:
if convidado.ID_CONVIDADO == 0:
cmd1 = ctx.tb_convidado.insert().values(
ID_EVENTO=evento.ID_EVENTO,
NOME_CONVIDADO=convidado.NOME_CONVIDADO,
CELULAR_CONVIDADO=convidado.CELULAR_CONVIDADO)
elif convidado.ID_CONVIDADO > 0:
cmd1 = ctx.tb_convidado.update().values(
NOME_CONVIDADO=convidado.NOME_CONVIDADO,
CELULAR_CONVIDADO=convidado.CELULAR_CONVIDADO).where(
ctx.mapConvidado.ID_CONVIDADO ==
convidado.ID_CONVIDADO)
ctx.session.execute(cmd1)
ctx.session.commit()
self.__ID_EVENTO = evento.ID_EVENTO
return True
except Exception as ex:
self.__loggerMySQL.testInsertLog(ex.args[0], kindOfLog.ERROR(),
traceback.format_exc())
return False
def testSaveUser(self, userMap=mapUser):
try:
self.assertTrue(self.saveUser(userMap))
self.__loggerMySQL.testInsertLog('Ok', kindOfLog.INFO(),
'Insert Ok')
return self.qBase.toJsonRoute("Ok", 200)
except AssertionError as ae:
_message = ae.args[0]
self.__loggerMySQL.testInsertLog(_message, kindOfLog.ERROR(),
traceback.format_exc())
return self.qBase.toJsonRoute(_message, 500)
def saveEmpresa(self, empresa=mapEmpresaContratante):
try:
cmd = None
if empresa.ID_EMPRESA > 0:
cmd = ctx.tb_empresa_contratante.update().values(
RAZAO_SOCIAL=empresa.RAZAO_SOCIAL.upper(),
NOME_FANTASIA=empresa.NOME_FANTASIA.upper(),
CNPJ=empresa.CNPJ.upper(),
IE=empresa.IE.upper(),
ENDERECO=empresa.ENDERECO.upper(),
NUMERO=empresa.NUMERO.upper(),
COMPLEMENTO=empresa.COMPLEMENTO.upper(),
CEP=empresa.CEP.upper(),
MUNICIPIO=empresa.MUNICIPIO.upper(),
UF=empresa.UF.upper(),
EMAIL=empresa.EMAIL.lower(),
TELEFONE=empresa.TELEFONE.upper(),
CONTATO=empresa.CONTATO.upper()).where(
ctx.mapEmpresaContratante.ID_EMPRESA ==
empresa.ID_EMPRESA)
elif empresa.ID_EMPRESA == 0:
cmd = ctx.tb_empresa_contratante.insert().values(
RAZAO_SOCIAL=empresa.RAZAO_SOCIAL.upper(),
NOME_FANTASIA=empresa.NOME_FANTASIA.upper(),
CNPJ=empresa.CNPJ.upper(),
IE=empresa.IE.upper(),
ENDERECO=empresa.ENDERECO.upper(),
NUMERO=empresa.NUMERO.upper(),
COMPLEMENTO=empresa.COMPLEMENTO.upper(),
CEP=empresa.CEP.upper(),
MUNICIPIO=empresa.MUNICIPIO.upper(),
UF=empresa.UF.upper(),
EMAIL=empresa.EMAIL.lower(),
TELEFONE=empresa.TELEFONE.upper(),
CONTATO=empresa.CONTATO.upper())
ctx.session.execute(cmd)
ctx.session.commit()
return True
except Exception as ex:
self.__loggerMySQL.testInsertLog(ex.args[0], kindOfLog.ERROR(),
traceback.format_exc())
return False
def testSave(self, empresa=mapEmpresaContratante):
try:
self.assertTrue(self.saveEmpresa(empresa))
self.__loggerMySQL.testInsertLog('Ok', kindOfLog.INFO(),
'Insert Ok')
return self.qBase.toJsonRoute("Ok", 200)
except AssertionError as ae:
_message = ae.args[0]
self.__loggerMySQL.testInsertLog(_message, kindOfLog.ERROR(),
traceback.format_exc())
return self.qBase.toJsonRoute(_message, 500)
def testAdicionaPresenca(self, ID_EVENTO, ID_CONVIDADO):
try:
self.assertTrue(self.adicionaPresenca(ID_EVENTO, ID_CONVIDADO))
self.__loggerMySQL.testInsertLog('Ok', kindOfLog.INFO(),
'Insert Ok')
return self.qBase.toJsonRoute("Ok", 200)
except AssertionError as ae:
_message = ae.args[0]
self.__loggerMySQL.testInsertLog(_message, kindOfLog.ERROR(),
traceback.format_exc())
return self.qBase.toJsonRoute(_message, 500)
def testSave(self, evento=mapEvento, convidado=mapConvidado):
try:
self.assertTrue(self.saveEvento(evento, convidado))
self.__loggerMySQL.testInsertLog('Ok', kindOfLog.INFO(),
'Insert Ok')
return self.qBase.toJsonRoute(str(self.__ID_EVENTO), 200)
except AssertionError as ae:
_message = ae.args[0]
self.__loggerMySQL.testInsertLog(_message, kindOfLog.ERROR(),
traceback.format_exc())
return self.qBase.toJsonRoute(_message, 500)
def saveUser(self, userMap=mapUser):
try:
pass1 = ''
if len(userMap.PASSWORD1) > 0:
pass1 = generate_password_hash(userMap.PASSWORD1)
cmd = None
if userMap.ID_USER > 0:
if len(pass1) == 0:
select1 = ctx.session.query(ctx.mapUser.PASSWORD1).filter(
ctx.mapUser.ID_USER == userMap.ID_USER).all()
pass1 = self.qBase.toDict(select1)[0]['PASSWORD1']
cmd = ctx.user.update().values(
NAME_USER = userMap.NAME_USER.upper(),
PASSWORD1 = pass1,
EMAIL = userMap.EMAIL.lower(),
KIND_OF_USER = userMap.KIND_OF_USER,
USER_ENABLED = userMap.USER_ENABLED).\
where(ctx.mapUser.ID_USER == userMap.ID_USER)
elif userMap.ID_USER == 0:
cmd = ctx.user.insert().values(
NAME_USER=userMap.NAME_USER.upper(),
PASSWORD1=pass1,
EMAIL=userMap.EMAIL.lower(),
KIND_OF_USER=userMap.KIND_OF_USER,
USER_ENABLED=userMap.USER_ENABLED)
ctx.session.execute(cmd)
ctx.session.commit()
return True
except Exception as ex:
self.__loggerMySQL.testInsertLog(ex.args[0], kindOfLog.ERROR(),
traceback.format_exc())
return False
def deleteUser(self, ID_USER):
try:
q = ctx.session.query(
ctx.mapUser).filter(ctx.mapUser.ID_USER == ID_USER)
if not ctx.session.query(q.exists()).scalar():
raise Exception('Usuário não encontrado')
del1 = ctx.user.delete().where(ctx.mapUser.ID_USER == ID_USER)
ctx.session.execute(del1)
ctx.session.commit()
return True
except Exception as ex:
_message = ex.args[0]
self.__loggerMySQL.testInsertLog(_message, kindOfLog.ERROR(),
traceback.format_exc())
return False
def deleteConvidado(self, ID_CONVIDADO):
try:
q = ctx.session.query(ctx.mapConvidado).filter(
ctx.mapConvidado.ID_CONVIDADO == ID_CONVIDADO)
if not ctx.session.query(q.exists()).scalar():
raise Exception('Convidado(a) não encontrado(a)')
del1 = ctx.tb_convidado.delete().where(
ctx.mapConvidado.ID_CONVIDADO == ID_CONVIDADO)
ctx.session.execute(del1)
ctx.session.commit()
return True
except Exception as ex:
_message = ex.args[0]
self.__loggerMySQL.testInsertLog(_message, kindOfLog.ERROR(),
traceback.format_exc())
return False
def deleteEmpresa(self, ID_EMPRESA):
try:
q = ctx.session.query(ctx.mapEmpresaContratante).filter(
ctx.mapEmpresaContratante.ID_EMPRESA == ID_EMPRESA)
if not ctx.session.query(q.exists()).scalar():
raise Exception('Empresa não encontrado')
del1 = ctx.tb_empresa_contratante.delete().where(
ctx.mapEmpresaContratante.ID_EMPRESA == ID_EMPRESA)
ctx.session.execute(del1)
ctx.session.commit()
return True
except Exception as ex:
_message = ex.args[0]
self.__loggerMySQL.testInsertLog(_message, kindOfLog.ERROR(),
traceback.format_exc())
return False
def deletePresenca(self, ID_CREDENCIAMENTO):
try:
q = ctx.session.query(ctx.mapCredenciamento).filter(
ctx.mapCredenciamento.ID_CREDENCIAMENTO == ID_CREDENCIAMENTO)
if not ctx.session.query(q.exists()).scalar():
raise Exception('Registro não encontrado')
del1 = ctx.tb_credenciamento.delete().where(
ctx.mapCredenciamento.ID_CREDENCIAMENTO == ID_CREDENCIAMENTO)
ctx.session.execute(del1)
ctx.session.commit()
return True
except Exception as ex:
_message = ex.args[0]
self.__loggerMySQL.testInsertLog(_message, kindOfLog.ERROR(),
traceback.format_exc())
return False