def atualiza_total_diario(db):
"""Cria coleção com estatística de total diário escaneamento."""
logger.debug('Inicio atualizaçap total diário escaneamento')
db['fs.files'].aggregate([{
'$match': {
'metadata.contentType': 'image/jpeg'
}
}, {
'$project': {
'yearMonthDay': {
'$dateToString': {
'format': '%Y-%m-%d',
'date': '$metadata.dataescaneamento'
}
}
}
}, {
'$group': {
'_id': '$yearMonthDay',
'count': {
'$sum': 1
}
}
}, {
'$out': 'total_diario_escaneamento'
}])
logger.debug('Fim atualização total diário escaneamento')
def get(cls, username, password=None):
"""Testa se Usuario existe. Se senha for passada, testa se é válida.
Retorna instância DBUser se usuário existe e senha válida, None se
Usuario não encontrado OU senha inválida.
"""
logger.debug('Getting user. dbsession= %s' % cls.dbsession)
if cls.dbsession:
username, password = cls.sanitize(username, password)
# logger.debug('DBSEssion %s' % cls.dbsession)
dbuser = DBUser(username, password)
user = cls.dbsession.users.find_one(
{'username': username})
if user is None:
return None
# logger.debug('***username %s, passed password %s ' % \
# (username, password))
if password is not None:
encripted = user['password']
logger.debug('encripted %s' % encripted)
if not dbuser.check(encripted):
return None
return DBUser(username, password)
else:
if username:
if (not password) or (username == password):
return DBUser(username, password)
return None
def atualiza_totais_recintos2(db):
"""Cria coleção com estatísticas de recinto por ano e mês."""
logger.debug('Inicio atualização consulta recintos 2')
db['fs.files'].aggregate([{
'$match': {
'metadata.contentType': 'image/jpeg'
}
}, {
'$project': {
'month': {
'$month': '$metadata.dataescaneamento'
},
'year': {
'$year': '$metadata.dataescaneamento'
},
'recinto': '$metadata.recinto'
}
}, {
'$group': {
'_id': {
'recinto': '$recinto',
'month': '$month',
'year': '$year'
},
'count': {
'$sum': 1
}
}
}, {
'$out': 'stat_recinto'
}])
logger.debug('Fim atualização consulta recintos 2')
def get(cls, username, password=None):
"""Testa se Usuario existe. Se senha for passada, testa se é válida.
Retorna instância DBUser se usuário existe e senha válida, None se
Usuario não encontrado OU senha inválida.
"""
logger.debug('Getting user. dbsession= %s' % cls.dbsession)
if cls.dbsession:
username, password = cls.sanitize(username, password)
# logger.debug('DBSEssion %s' % cls.dbsession)
dbuser = DBUser(username, password)
dbcomunicator = UserDBComunication(cls.dbsession,
cls.alchemy_class)
user = dbcomunicator.get(username)
if user is None:
return None
if password is not None:
encripted = user['password']
logger.debug('encripted %s' % encripted)
if not dbuser.check(encripted):
return None
return DBUser(username, password)
else:
if username:
if (not password) or (username == password):
return DBUser(username, password)
return None
def adiciona_base(nome):
"""Cria nova instância de Base Origem com o nome passado."""
dbsession = app.config.get('dbsession')
logger.debug(nome)
nova_base = BaseOrigem(nome)
dbsession.add(nova_base)
dbsession.commit()
baseid = nova_base.id
return redirect(url_for('importa_base', baseid=baseid))
def get_pesagens_dte(datainicial, datafinal, recinto, token):
payload = {'data_inicio': datetime.strftime(datainicial, '%Y-%m-%d'),
'data_fim': datetime.strftime(datafinal, '%Y-%m-%d'),
'cod_recinto': recinto}
headers = {'Authorization': 'Bearer ' + token}
r = requests.get(DTE_URL, headers=headers, params=payload, verify=False)
logger.debug('get_pesagens_dte ' + r.url)
try:
lista_pesagens = r.json()['JUP_WS']['Pesagens']['Lista_Pesagens_Movimentacao']
except:
logger.error(r, r.text)
return lista_pesagens
def adiciona_padrao(nome):
"""Função que adiciona um novo padrão de riscos.
Args:
nome: Nome do padrão a ser inserido no Banco de Dados
"""
dbsession = app.config.get('dbsession')
logger.debug(nome)
novo_padrao = PadraoRisco(nome)
dbsession.add(novo_padrao)
dbsession.commit()
padraoid = novo_padrao.id
return redirect(url_for('edita_risco', padraoid=padraoid))
def change_password(cls, username, password):
"""Cria usuário ou muda senha se ele existe."""
if not cls.dbsession:
raise Exception('Sem conexão com o Banco de Dados!')
username, password = cls.sanitize(username, password)
encripted = cls.encript(password)
cursor = cls.dbsession.users.update_one(
{'username': username},
{"$set": {'username': username,
'password': encripted}}
)
logger.debug('cursor', cursor)
return True
def plot_pie_plotly(values, labels):
"""Gera gráfico de terminais."""
# labels = ['1', '2', '3']
# values = [10, 20, 30]
logger.debug(labels)
logger.debug(values)
plot = plotly.offline.plot(
{
'data': [go.Pie(labels=labels, values=values)],
'layout': go.Layout(title='Imagens por Recinto')
},
show_link=False,
output_type='div')
return plot
def model_process(model: str):
try:
local_model = BaseModel(os.path.join(MODEL_DIRECTORY, model))
except Exception as err:
local_model = FailLoadModel(str(err))
logger.debug(err, exc_info=True)
# continually poll for new images to classify
while True:
time.sleep(SERVER_SLEEP)
queue = redisdb.lrange(PADMA_REDIS, 0, BATCH_SIZE - 1)
if queue:
logger.debug('Processo %s - processing image classify from queue' %
model)
for cont, q in enumerate(queue, 1):
d = pickle.loads(q)
model_key = d.get('model')
logger.debug(model_key + ' - ' + model)
if model_key == model:
try:
# t = Thread(target=model_predict, args=(
# [local_model, d['id'], d['image']]))
# t.daemon = True
# t.start()
model_predict(local_model, d['id'], d['image'])
except Exception as err:
logger.error('Erro ao recuperar modelo %s' % model_key)
logger.error(str(q))
logger.debug(err, exc_info=True)
output = {'success': False, 'erro': str(err)}
dump = json.dumps(output)
redisdb.set(d['id'], dump)
finally:
redisdb.ltrim(PADMA_REDIS, cont, -1)
def plot_bar_plotly(values, labels):
"""Gera gráfico de barras."""
# x = list(range(len(labels)))
logger.debug(labels)
logger.debug(values)
plot = plotly.offline.plot(
{
'data': [go.Bar(x=labels, y=values)],
'layout': go.Layout(title='',
xaxis=go.layout.XAxis(type='category'))
},
show_link=False,
output_type='div',
image_width=400)
return plot
def atualiza_stats(db, tipo='all'):
"""Recebe tipo, roda atualização de estat[istica correspondente."""
logger.debug('Atualiza stats. Tipo: %s' % tipo)
atualizacoes = {
'recintos2': atualiza_totais_recintos2,
}
if tipo == 'all':
for key, func in atualizacoes.items():
func(db)
else:
func = tipo.get(tipo)
if func is None:
logger.debug('Atualiza stats. Tipo %s inexistente' % tipo)
else:
func(db)
def get_gmci(datainicial, datafinal, token):
payload = {
'DataInicial': datetime.strftime(datainicial, '%d/%m/%Y %H:%M:%S'),
'DataFinal': datetime.strftime(datafinal, '%d/%m/%Y %H:%M:%S')
}
headers = {'Authorization': 'Bearer ' + token}
print(payload)
r = requests.post(GMCI_URL, headers=headers, data=payload, verify=False)
logger.debug('get_gmci ' + r.url)
print('get_gmci', r.url)
try:
lista_gmci = r.json()
return lista_gmci
except:
logger.error(r, r.text)
def update(self, username, encripted, password):
if self.type == DBType.mongo:
cursor = self.dbsession.users.update_one(
{'username': username},
{"$set": {
'username': username,
'password': encripted
}},
upsert=True)
logger.debug('cursor', cursor)
elif self.type == DBType.sqlalchemy:
user = self.dbsession.query(self.alchemy_class). \
filter(self.alchemy_class.cpf == username).one()
user.password = password
self.dbsession.add(user)
self.dbsession.commit()
def model_predict(model, _id, image):
s0 = time.time()
try:
predictions = model.predict(image)
# print('preds', output)
output = {'success': True, 'predictions': predictions}
dump = json.dumps(output)
redisdb.set(_id, dump)
s1 = time.time()
logger.debug('Images classified in %s ' % (s1 - s0))
except Exception as err:
logger.error('Erro em model_predict %s' % str(model))
logger.error(str(_id))
logger.debug(err, exc_info=True)
output = {'success': False, 'predictions': [], 'erro': str(err)}
dump = json.dumps(output)
redisdb.set(_id, dump)
def gridfs_count(db, filtro={}, limit=2000, campos=[]):
"""Aplica filtro, retorna contagem."""
if filtro:
if not campos:
campos = [(key, 1) for key in filtro.keys()]
logger.debug('integracao.gridfs_count filtro:%s hint:%s' %
(filtro, campos))
try:
params = dict(filter=filtro, hint=campos)
if limit:
params['limit'] = limit
print(params)
return db['fs.files'].count_documents(**params)
except OperationFailure as err:
logger.error(err)
params.pop('hint')
return db['fs.files'].count_documents(**params)
return db['fs.files'].count_documents({})
def mount_filtros(self):
"""Para evitar a criação desmesurada de filtros eles serão centralizados.
Aqui, se a tabela não existir no banco, cria algumas hard_coded.
Depois, o administrador poderá criar novas no BD.
"""
cursor = self.db['Auditorias'].find()
auditorias = list(cursor)
if len(auditorias) == 0:
logger.debug('Criando tabela Auditorias...')
# Se não existe tabela, cria, preenche e chama de novo mesmo método
for id, campos in self.FILTROS_AUDITORIA.items():
logger.debug(id + ' ' + campos['descricao'])
self.db['Auditorias'].insert_one({
'id':
id,
'filtro':
json.dumps(campos['filtro']),
'order':
json.dumps(campos['order']),
'descricao':
campos['descricao']
})
# self.add_relatorio(id, **campos)
self.mount_filtros()
return
for row in auditorias:
id = row['id']
self.dict_auditoria[id] = {
'filtro': json.loads(row['filtro']),
'order': json.loads(row['order']),
'descricao': row['descricao']
}
self.filtros_auditoria_desc.append((id, row['descricao']))
# logger.debug(self.filtros_auditoria_desc)
self.filtros_auditoria_desc = sorted(self.filtros_auditoria_desc)
def classify_process():
# Load the pre-trained models, only once.
# Then wait for incoming queries on redis
modeldict = dict()
logger.info('Carregando modelos Dinâmicos/processo')
try:
models = os.listdir(MODEL_DIRECTORY)
load_models_new_process(modeldict, models)
except FileNotFoundError:
logger.warning('Caminho %s não encontrado!!!' % MODEL_DIRECTORY)
logger.info('Carregando modelos HARDCODED')
load_models_hardcoded(modeldict)
logger.info('Fim dos carregamentos...')
# continually poll for new images to classify
while True:
# attempt to grab a batch of images from the database
time.sleep(SERVER_SLEEP)
queue = redisdb.lrange(PADMA_REDIS, 0, BATCH_SIZE - 1)
# loop over the queue
if queue:
cont = 0
model_key = 'nao definido'
try:
logger.debug('Processing image classify from queue')
for q in queue:
cont += 1
d = pickle.loads(q)
model_key = d.get('model')
model_item = modeldict.get(model_key)
if model_item is None:
try:
model_key = str(model_key)
except TypeError as err:
logger.error(err, exc_info=True)
model_key = 'ERRO!!'
logger.debug('model_item None model_key %s' %
model_key)
# Se existir mas não está carregado, carrega do disco.
if os.path.exists(
os.path.join(MODEL_DIRECTORY, model_key)):
load_models_new_process(modeldict, [model_key])
output = {
'success': False,
'erro': 'Modelo %s ainda não carregado.' + \
'Tente novamente.' % model_key
}
else:
logger.debug(
'Solicitado modelo não existente: "%s"' %
model_key)
output = {
'success': False,
'erro':
'Modelo não existente: %s.' % model_key,
'modelos': list(modeldict.keys())
}
dump = json.dumps(output)
redisdb.set(d['id'], dump)
else:
# Testar se é modelo dinâmico. Se for, não faz nada
# pois há outro processo tratando.
if not isinstance(model_item, Process):
logger.debug('Enviando para thread %s %s' %
(model_key, model_item))
t = Thread(target=model_predict,
args=([model_item, d['id'],
d['image']]))
t.daemon = True
t.start()
# model_predict(model_item, d['id'], d['image'])
except Exception as err:
logger.error('Erro ao recuperar modelo %s' % model_key)
logger.error(str(q))
logger.debug(err, exc_info=True)
output = {'success': False, 'erro': str(err)}
dump = json.dumps(output)
redisdb.set(d['id'], dump)
finally:
# Testar se é modelo dinâmico. Se for, não faz nada
# pois há outro processo tratando.
if not isinstance(model_item, Process):
redisdb.ltrim(PADMA_REDIS, cont, -1)
def unauthorized(args):
"""Gerenciador de usuário não autorizado padrão do flask-login."""
logger.debug(args)
message = 'Não autorizado! ' + \
'Efetue login novamente com usuário e senha válidos.'
return redirect(url_for('commons.login', message=message))
def parametros_fromcsv(self,
campo,
session=None,
padraorisco=None,
lista=None,
path=tmpdir):
"""Carrega parâmetros de risco de um aquivo ou de uma lista.
Abre um arquivo csv, recupera parâmetros configurados nele,
adiciona à configuração do gerente e **também adiciona ao Banco de
Dados ativo** caso não existam nele ainda. Para isso é preciso
passar a session como parâmetro, senão cria apenas na memória
Pode receber uma lista no lugar de um arquivo csv (como implementado
em import_named_csv).
Ver também:
:py:func:`parametros_tocsv`
:py:func:`import_named_csv`
Args:
campo: nome do campo a ser filtrado e deve ser também
o nome do arquivo .csv
session: a sessão com o banco de dados
lista: passar uma lista pré-prenchida para usar a função com outros
tipos de fontes/arquivos. Se passada uma lista, função não
abrirá arquivo .csv, usará os valores da função
*OU*
path: caminho do arquivo .csv
Obs:
O arquivo .csv ou a lista DEVEM estar no formato valor, tipo_filtro
"""
logger.debug('CSV recebido')
if not lista:
with open(os.path.join(path, campo + '.csv'),
'r',
encoding=ENCODE,
newline='') as f:
reader = csv.reader(f)
next(reader)
lista = [linha for linha in reader]
logger.debug('CSV lido com %s linhas' % len(lista))
if session:
parametro = session.query(ParametroRisco).filter(
ParametroRisco.nome_campo == campo).first()
if not parametro:
parametro = ParametroRisco(campo, padraorisco=padraorisco)
session.add(parametro)
session.commit()
logger.debug('Salvando csv em %s' % parametro)
for linha in lista:
if parametro.id:
if len(linha) == 1:
ltipofiltro = Filtro.igual
else:
ltipofiltro = Filtro[linha[1].strip()]
valor = session.query(ValorParametro).filter(
ValorParametro.valor == linha[0],
ValorParametro.risco_id == parametro.id).first()
if not valor:
valor = ValorParametro(linha[0].strip(), ltipofiltro)
valor.risco_id = parametro.id
session.add(valor)
else:
valor.tipo_filtro = ltipofiltro
valor.risco_id = parametro.id
session.merge(valor)
parametro.valores.append(valor)
session.merge(parametro)
session.commit()
self.add_risco(parametro)
else:
dict_filtros = defaultdict(list)
for linha in lista:
if len(linha) == 1:
ltipofiltro = Filtro.igual
else:
ltipofiltro = Filtro[linha[1].strip()]
dict_filtros[ltipofiltro].append(linha[0])
self._riscosativos[campo] = dict_filtros
def stats_resumo_imagens(db, datainicio=None, datafim=None):
"""Números gerais do Banco de Dados e suas integrações.
Estatísticas gerais sobre as imagens
"""
stats = OrderedDict()
filtro = IMAGENS
if datainicio and datafim:
logger.debug('STATS IMAGENS Inicio %s Fim %s.' % (datainicio, datafim))
filtro['metadata.dataescaneamento'] = {
'$gt': datainicio,
'$lt': datafim
}
logger.debug('Consultando Totais')
now_atual = datetime.now()
stats['Data do levantamento'] = now_atual
stats['Periodo do levantamento'] = 'Inicio %s Fim %s.' % (datainicio,
datafim)
total = gridfs_count(db, filtro, limit=None)
logger.debug('Total %s ' % filtro)
stats['Total de imagens'] = total
filtro_carga = dict(filtro, **carga.FALTANTES)
stats['Imagens com info do Carga'] = total - \
gridfs_count(db, filtro_carga,
limit=None)
filtro_xml = dict(filtro, **xmli.FALTANTES)
stats['Imagens com info do XML'] = total - \
gridfs_count(db, filtro_xml,
limit=None)
filtro_padma = dict(filtro, **padma.FALTANTES)
count_padma = gridfs_count(db, filtro_padma, limit=None)
stats['Imagens com bbox do Padma'] = total - count_padma
filtro_pesagem = dict(filtro, **info_ade02.FALTANTES)
stats['Imagens com informações de Pesagem'] = total - \
gridfs_count(db, filtro_pesagem,
limit=None)
# DATAS
logger.debug('Totais consultados')
datas = OrderedDict()
datas['imagem'] = DATA
datas['XML'] = xmli.DATA
datas['Carga'] = carga.DATA
datas['Pesagem'] = info_ade02.DATA
for base, data in datas.items():
filtro_data = dict(filtro)
if filtro_data.get(data):
filtro_data[data].update({'$ne': None})
else:
filtro_data[data] = {'$ne': None}
campos = [(key, 1) for key in filtro_data.keys()]
logger.debug('Inicio consulta data projection:%s Filtro:%s Hint:%s' %
(data, filtro_data, campos))
adata, data_path = get_data(db, data, filtro_data, campos)
stats['Menor ' + data_path + ' ' + base] = adata
adata, data_path = get_data(db, data, filtro_data, campos, -1)
stats['Maior ' + data_path + ' ' + base] = adata
# Qtde por Terminal
logger.debug('Inicio consulta recintos 1. Filtro: %s ' % filtro)
cursor = db['fs.files'].aggregate([{
'$match': filtro
}, {
'$group': {
'_id': '$metadata.recinto',
'count': {
'$sum': 1
}
}
}])
recintos = dict()
for recinto in cursor:
rid = recinto['_id']
if rid is not None:
recintos[rid] = recinto['count']
ordered = OrderedDict()
# print(recintos.keys())
for key in sorted(recintos.keys()):
ordered[key] = recintos[key]
stats['recinto'] = ordered
logger.debug('Inicio consulta recintos 2')
cursor = db['stat_recinto'].find()
recinto_mes = defaultdict(dict)
for linha in cursor:
recinto = linha['_id'].get('recinto')
if recinto is not None:
ano_mes = '%04d%02d' % (linha['_id']['year'],
linha['_id']['month'])
recinto_mes[recinto][ano_mes] = linha['count']
for recinto, value in recinto_mes.items():
ordered = OrderedDict({key: value[key] for key in sorted(value)})
recinto_mes[recinto] = ordered
stats['recinto_mes'] = recinto_mes
logger.debug('Fim consulta recintos 2')
return stats
def importa_base():
"""Função para upload do arquivo de uma extração ou outra fonte externa.
Utiliza o :class: `bhadrasana.utils.gerenterisco.GerenteRisco`.
Suporte por ora para csv com títulos e zip com sch (padrão Carga)
Necessita um Servidor Celery para repassar responsabilidade.
Ver também :func: `bhadrasana.workers.tasks.importar_base`
Args:
baseid: ID da Base de Origem do arquivo
data: data inicial do período extraído (se não for passada,
assume hoje)
file: arquivo csv, sch+txt, ou conjunto deles em formato zip
"""
dbsession = app.config.get('dbsession')
# print('dbsession', dbsession)
baseid = request.form.get('baseid')
data = request.form.get('data')
sync = request.args.get('sync')
if request.method == 'POST':
if 'file' not in request.files:
flash('Arquivo vazio. Selecionar arquivo válido'
' e depois clicar em submeter!')
else:
file = request.files['file']
filename = secure_filename(file.filename)
if (not filename or not allowed_file(filename)):
flash('Selecionar arquivo válido e depois clicar em submeter!')
filename = None
else:
if baseid is None or baseid == 0:
flash('Selecionar base original e clicar em submeter!')
else: # Validado - tentar upload e procesamento
try:
abase = dbsession.query(BaseOrigem).filter(
BaseOrigem.id == baseid).first()
if abase is None:
raise ValueError('Informe uma base válida!!!')
if not data:
data = datetime.date.today().strftime('%Y-%m-%d')
logger.debug(data)
logger.debug(current_user.name)
tempfile_name = os.path.join(tmpdir, filename)
file.save(tempfile_name)
# Passa responsabilidade de processamento da base
# para o processo Celery
user_folder = os.path.join(CSV_FOLDER,
current_user.name)
if sync:
flash(importar_base_sync(user_folder,
abase.id,
data,
tempfile_name,
True))
return redirect(url_for('risco',
baseid=baseid))
else:
task = importar_base.delay(user_folder,
abase.id,
data,
tempfile_name,
True)
return redirect(url_for('risco',
baseid=baseid,
taskid=task.id))
except Exception as err:
logger.error(err, exc_info=True)
flash(err)
bases = dbsession.query(BaseOrigem).order_by(BaseOrigem.nome).all()
return render_template('importa_base.html', bases=bases,
baseid=baseid, data=data)
def aplica_juncao(self,
visao,
path=tmpdir,
filtrar=False,
parametros_ativos=None):
"""Faz junção de arquivos diversos.
Lê, um a um, os csvs configurados em visao.tabelas. Carrega em
DataFrames e faz merge destes.
Args:
visao: objeto de Banco de Dados que espeficica as configurações
(metadados) da base
path: caminho da base de arquivos csv
filtrar: aplica_risco após merge dos DataFrames
parametros_ativos: subconjunto do parâmetros de risco a serem
aplicados
Returns:
Lista contendo os campos filtrados. 1ª linha com nomes de campo.
Obs:
Quando a base for constituída de arquivo único, utilizar
:func:`aplica_risco`
"""
numero_juncoes = len(visao.tabelas)
tabela = visao.tabelas[0]
print('CSV File', tabela.csv_file)
filename = os.path.join(path, tabela.csv_file)
dfpai = pd.read_csv(filename, encoding=ENCODE, dtype=str)
logger.debug('DataFrame criado. Tabela %s. %s linhas ' %
(tabela.csv_file, len(dfpai)))
if hasattr(tabela, 'type'):
how = tabela.type
else:
how = 'inner'
for r in range(1, numero_juncoes):
primario = tabela.primario.lower()
if hasattr(tabela, 'type'):
how = tabela.type
else:
how = 'inner'
tabela = visao.tabelas[r]
estrangeiro = tabela.estrangeiro.lower()
filhofilename = os.path.join(path, tabela.csv_file)
dffilho = pd.read_csv(filhofilename, encoding=ENCODE, dtype=str)
logger.debug('DataFrame criado. Tabela % s. Linhas %s ' %
(tabela.csv_file, len(dffilho)))
try:
dfpai = dfpai.merge(dffilho,
how=how,
left_on=primario,
right_on=estrangeiro)
logger.debug('Merge realizado usando tabelas anteriores ' +
'primario % s, estrangeiro %s, linhas %s ' %
(primario, estrangeiro, len(dffilho)))
except KeyError as err:
logger.error('Erro ao fazer merge 1!')
msg = 'Erro ao montar consulta 1. KeyError: %s.' % str(err) + \
' Tabela %s primario %s estrangeiro %s' % \
(tabela.csv_table, primario, estrangeiro)
msglog = msg + '\n' + \
'**dffilho: %s ' % ', '.join(dffilho.columns) + '\n' \
'**dfpai %s ' % ', '.join(dfpai.columns)
logger.error(msglog)
raise KeyError(msg)
"""
csv_pai = visao.tabelas[0].csv_file
paifilename = os.path.join(path, csv_pai)
dfpai = pd.read_csv(paifilename, encoding=ENCODE, dtype=str)
logger.debug('DataFrame criado. Tabela % s ' % csv_pai)
# print(tabela.csv_file, tabela.estrangeiro, tabela.primario)
try:
if dffilho is not None:
dfpai = dfpai.merge(dffilho, how=how,
left_on=tabela.primario.lower(),
right_on=tabela.estrangeiro.lower())
logger.debug('Merge realizado usando tabelas anteriores ' +
'primario % s, estrangeiro %s, linhas %s' %
(tabela.primario, tabela.estrangeiro, len(dfpai))
)
except KeyError as err:
logger.error('Erro ao fazer merge 2!')
msg = 'Erro ao montar consulta 2. KeyError: %s.' % str(err) + \
' Tabela %s primario %s estrangeiro %s' % \
(tabela.csv_table, tabela.primario, tabela.estrangeiro)
msglog = msg + '\n' + \
'**dffilho: %s ' % ', '.join(dffilho.columns) + '\n' \
'**dfpai %s ' % ', '.join(dfpai.columns)
logger.error(msglog)
raise KeyError(msg)
# print(dfpai)
"""
if visao.colunas:
colunas = [coluna.nome.lower() for coluna in visao.colunas]
try:
result_df = dfpai[colunas]
except KeyError as err:
msg = 'Erro ao selecionar colunas. KeyError: ' + str(err) + \
' Colunas disponíveis: %s ' % \
', '.join(dfpai.columns)
logger.error(msg)
raise KeyError(msg)
result_list = [colunas]
else:
result_df = dfpai
result_list = [result_df.columns.tolist()]
result_list.extend(result_df.values.tolist())
# print(result_list)
if filtrar:
return self.aplica_risco(result_list,
parametros_ativos=parametros_ativos)
return result_list
def files():
"""Recebe parâmetros, aplica no GridFS, retorna a lista de arquivos."""
db = app.config['mongodb']
PAGE_ROWS = 50
PAGES = 100
lista_arquivos = []
campos = campos_chave()
npaginas = 1
pagina_atual = 1
count = 0
order = None
tags_object = Tags(db)
auditoria_object = Auditoria(db)
form_files = FilesForm(start=date.today() - timedelta(days=10),
end=date.today())
form_files.filtro_tags.choices = tags_object.tags_text
form_files.filtro_auditoria.choices = auditoria_object.filtros_auditoria_desc
filtro, user_filtros = recupera_user_filtros()
if request.method == 'POST':
# print('****************************', request.form)
form_files = FilesForm(**request.form)
form_files.filtro_tags.choices = tags_object.tags_text
form_files.filtro_auditoria.choices = auditoria_object.filtros_auditoria_desc
filtro, pagina_atual, order = valida_form_files(form_files, filtro, db)
else:
numero = request.args.get('numero')
if numero:
form_files = FilesForm(numero=numero)
form_files.filtro_tags.choices = tags_object.tags_text
form_files.filtro_auditoria.choices = auditoria_object.filtros_auditoria_desc
filtro['metadata.numeroinformado'] = mongo_sanitizar(
numero).upper()
if filtro:
filtro['metadata.contentType'] = 'image/jpeg'
if order is None:
order = [('metadata.dataescaneamento', 1)]
if pagina_atual is None:
pagina_atual = 1
projection = {
'_id': 1,
'filename': 1,
'metadata.numeroinformado': 1,
'metadata.predictions': 1,
'metadata.pesagens': 1,
'metadata.dataescaneamento': 1,
'metadata.carga': 1
}
skip = (pagina_atual - 1) * PAGE_ROWS
logger.debug(filtro)
logger.debug(projection)
logger.debug('order: %s' % order)
logger.debug(PAGE_ROWS)
logger.debug(skip)
count = db['fs.files'].count_documents(filtro, limit=PAGES * PAGE_ROWS)
# print(count)
# count = 100
npaginas = (count - 1) // PAGE_ROWS + 1
# print('**Página:', pagina_atual, skip, type(skip))
# print(count, skip)
for grid_data in db['fs.files'] \
.find(filter=filtro, projection=projection) \
.sort(order) \
.limit(PAGE_ROWS).skip(skip):
linha = {}
linha['_id'] = grid_data['_id']
linha['filename'] = grid_data['filename']
linha['dataescaneamento'] = datetime.strftime(
grid_data['metadata'].get('dataescaneamento'),
'%-d/%m/%Y %H:%M:%S')
linha['ncms'] = carga.get_dados_ncm(grid_data)
linha['infocarga'] = carga.get_dados_conteiner(grid_data)
linha['pesocarga'] = carga.get_peso_conteiner(grid_data)
linha['infodue'] = due_mongo.get_dados(grid_data)
linha['peso'] = carga.get_pesos(grid_data)
linha['numero'] = grid_data['metadata'].get('numeroinformado')
linha['conhecimento'] = carga.get_conhecimento(grid_data)
lista_arquivos.append(linha)
# print(lista_arquivos)
if len(lista_arquivos) < 50:
npaginas = pagina_atual
return render_template('search_files.html',
paginated_files=lista_arquivos,
oform=form_files,
campos=campos,
filtros=user_filtros,
npaginas=npaginas,
nregistros=count)
def edita_risco():
"""Editar Padrões e Valores de Risco.
Tela para configurar os parâmetros de risco das bases importadas,
permite a alteração e criação de novos parâmetros e seus dados.
Args:
padraoid: ID do padrão de risco criado e/ou escolhido para
realizar a alteração
riscoid: ID do objeto de risco para aplicar a edição
"""
user_folder = os.path.join(CSV_FOLDER, current_user.name)
dbsession = app.config.get('dbsession')
padraoid = request.args.get('padraoid')
baseid = request.args.get('baseid')
padroes = dbsession.query(PadraoRisco).order_by(PadraoRisco.nome).all()
bases = dbsession.query(BaseOrigem).order_by(BaseOrigem.nome).all()
parametros = []
headers = []
basesid = []
if padraoid:
padrao = dbsession.query(PadraoRisco).filter(
PadraoRisco.id == padraoid
).first()
if padrao:
basesid = padrao.bases
parametros = padrao.parametros
riscoid = request.args.get('riscoid')
valores = []
if riscoid:
valor = dbsession.query(ParametroRisco).filter(
ParametroRisco.id == riscoid
).first()
if valor:
valores = valor.valores
headers = []
if basesid:
logger.debug(basesid)
for base in basesid:
gerente = GerenteRisco()
logger.debug(base)
base_id = base.id
headers = gerente.get_headers_base(
base_id, path=user_folder)
headers = list(headers)
base_headers = [depara.titulo_novo for depara in
dbsession.query(DePara).filter(
DePara.base_id == base_id
).all()]
base_headers = list(base_headers)
headers.extend(base_headers)
if len(headers) == 0:
flash('Aviso: nenhuma base exemplo ou configuração muda títulos '
'encontrada para sugestão de campo parâmetro.')
headers.sort()
logger.debug(headers)
return render_template('edita_risco.html',
padraoid=padraoid,
baseid=baseid,
padroes=padroes,
bases=bases,
basesid=basesid,
riscoid=riscoid,
parametros=parametros,
lista_autocomplete=headers,
valores=valores)
def load_mongo(self,
db,
base=None,
collection_name=None,
parametros_ativos=None,
limit=0,
skip=0):
"""Recupera da base mongodb em um lista.
Args:
db: "MongoDBClient" conexão com o banco de dados selecionado.
base: Base Origem
**OU**
collection_name: nome da coleção do MongoDB
parametros_ativos: subconjunto do parâmetros de risco a serem
aplicados
Returns:
Lista contendo os campos filtrados. 1ª linha com nomes de campo
"""
if base is None and collection_name is None:
raise AttributeError('Base Origem ou collection name devem ser'
'obrigatoriamente informado')
logger.debug(parametros_ativos)
if parametros_ativos:
riscos = set(
[parametro.lower() for parametro in parametros_ativos])
else:
riscos = set([key.lower() for key in self._riscosativos.keys()])
filtro = {}
listadefiltros = []
for campo in riscos:
dict_filtros = self._riscosativos.get(campo)
# TODO: $or operator, filter operator
for tipo_filtro, lista_filtros in dict_filtros.items():
filtro = {campo: {'$in': lista_filtros}}
listadefiltros.append(filtro)
if listadefiltros:
filtro = {'$or': listadefiltros}
logger.debug(filtro)
if collection_name:
if collection_name.find('.csv') != -1:
collection_name = collection_name[:-4]
list_collections = [collection_name]
else:
list_collections = [
name for name in db.collection_names() if base.nome in name
]
result = OrderedDict()
for collection_name in list_collections:
mongo_list = db[collection_name].find(filtro).limit(limit).skip(
skip)
if mongo_list.count() == 0:
filtro = {}
mongo_list = db[collection_name].find(filtro)
try:
headers = [[key for key in mongo_list[0].keys()]]
# number_of_headers = len(headers)
except IndexError as err:
logger.error('load_mongo retornou vazio. Collection name:')
logger.error(collection_name)
logger.error(err, exc_info=True)
return []
for linha in mongo_list:
for key, value in linha.items():
if result.get(key) is None:
result[key] = []
result[key].append(value)
# result.append(valores)
# logger.debug('Result ')
# logger.debug(result)
headers = [key for key in result.keys()]
comprimento = len(result[headers[0]])
lista = [headers]
for i in range(comprimento - 1):
linha = []
for key in headers:
try:
linha.append(result[key][i])
except IndexError:
continue
lista.append(linha)
return lista
def tag(word: str, tags: list):
"""Coloca tags em torno de word."""
open_tags = ['<' + tag + '>' for tag in tags]
close_tags = ['</' + tag + '>' for tag in reversed(tags)]
logger.debug('*************** %s ' % word)
return ''.join(open_tags) + word + ''.join(close_tags)
def unauthorized(args):
"""Gerenciador de usuário não autorizado padrão do flask-login."""
logger.debug(args)
message = 'Não autorizado! ' + \
'Efetue login novamente com usuário e senha válidos.'
return redirect(get_next_url_login())