def verify_password(username, password):
username = mongo_sanitizar(username)
# Não aceitar senha vazia!!
password = mongo_sanitizar(password)
user = authenticate(username, password)
if user is not None:
logger.info('Usuário %s %s autenticou via API' %
(user.id, user.name))
return user
def valida(self):
"""Lê formulário e adiciona campos ao filtro se necessário."""
if self.validate(): # configura filtro básico
self.filtro = {}
# pagina_atual = self.pagina_atual.data
numero = self.numero.data
start = self.start.data
end = self.end.data
alerta = self.alerta.data
zscore = self.zscore.data
if numero == 'None':
numero = None
if start and end:
start = datetime.combine(start, datetime.min.time())
end = datetime.combine(end, datetime.max.time())
self.filtro['metadata.dataescaneamento'] = {'$lte': end, '$gte': start}
if numero:
self.filtro['metadata.numeroinformado'] = \
{'$regex': '^' + mongo_sanitizar(self.numero), '$options': 'i'}
if alerta:
self.filtro['metadata.xml.alerta'] = True
if zscore:
self.filtro['metadata.zscore'] = {'$gte': zscore}
# Auditoria
filtro_escolhido = self.filtro_auditoria.data
if filtro_escolhido and filtro_escolhido != '0':
auditoria_object = Auditoria(self.db)
filtro_auditoria = \
auditoria_object.dict_auditoria.get(filtro_escolhido)
if filtro_auditoria:
self.filtro.update(filtro_auditoria.get('filtro'))
order = filtro_auditoria.get('order')
tag_escolhida = self.filtro_tags.data
tag_usuario = self.tag_usuario.data
if tag_escolhida and tag_escolhida != '0':
filtro_tag = {'tag': tag_escolhida}
if tag_usuario:
filtro_tag.update({'usuario': current_user.id})
self.filtro['metadata.tags'] = {'$elemMatch': filtro_tag}
texto_ocorrencia = self.texto_ocorrencia.data
if texto_ocorrencia:
self.filtro.update(
{'metadata.ocorrencias': {'$exists': True},
'metadata.ocorrencias.texto':
{'$regex':
'^' + mongo_sanitizar(texto_ocorrencia), '$options': 'i'
}
})
print('FILTRO: ', self.filtro)
return True
return False
def file(_id=None):
"""Tela para exibição de um 'arquivo' do GridFS.
Exibe o arquivo e os metadados associados a ele.
"""
db = app.config['mongodb']
fs = GridFS(db)
tags_object = Tags(db)
form_tags = TagsForm()
form_tags.tags.choices = tags_object.tags_text
if request.args.get('filename'):
filename = mongo_sanitizar(request.args.get('filename'))
logger.warn('Filename %s ' % filename)
grid_data = fs.find_one({'filename': filename})
else:
if not _id:
_id = request.args.get('_id')
grid_data = fs.get(ObjectId(_id))
# print(grid_data)
if grid_data:
summary_ = dict_to_html(summary(grid_data=grid_data))
summary_carga = dict_to_html(carga.summary(grid_data=grid_data))
tags = tags_object.list(_id)
ocorrencias = Ocorrencias(db).list(_id)
else:
summary_ = summary_carga = 'Arquivo não encontrado.'
ocorrencias = []
return render_template('view_file.html',
myfile=grid_data,
summary=summary_,
summary_carga=summary_carga,
form_tags=form_tags,
tags=tags,
ocorrencias=ocorrencias)
def get_dues_container(mongodb,
numero: str,
datainicio: datetime,
datafim: datetime,
limit=40) -> List[dict]:
if numero is None or numero == '':
raise ValueError('get_dues: Informe o número do contêiner!')
query = {
'metadata.numeroinformado': mongo_sanitizar(numero.strip()).upper(),
'metadata.dataescaneamento': {
'$gte': datainicio,
'$lte': datafim
},
'metadata.contentType': 'image/jpeg'
}
projection = {'metadata.due': 1}
cursor = mongodb['fs.files'].find(query, projection). \
sort('metadata.dataescaneamento', pymongo.DESCENDING).limit(limit)
result = []
for row in cursor:
metadata = row.get('metadata')
if metadata:
due = metadata.get('due')
if due:
result.append(due[0])
return result
def filtro():
"""Configura filtro personalizado."""
_, user_filtros = recupera_user_filtros()
if user_filtros is None:
return jsonify([])
# print(request.form)
# print(request.args)
campo = request.args.get('campo')
if campo:
valor = request.args.get('valor')
if valor: # valor existe, adiciona
if campos_chave_tipos().get(campo) == bool:
valor = valor.lower()
user_filtros[campo] = (valor == 's' or valor == 'true'
or valor == 'sim')
elif campos_chave_tipos().get(campo) == date:
# print('DATE!!!', valor)
ldata = datetime.strptime(valor, '%Y/%m/%d')
start = datetime.combine(ldata, datetime.min.time())
end = datetime.combine(ldata, datetime.max.time())
user_filtros[campo] = {'$lte': end, '$gte': start}
else:
user_filtros[campo] = mongo_sanitizar(valor)
else: # valor não existe, exclui chave
user_filtros.pop(campo)
result = [{'campo': k, 'valor': v} for k, v in user_filtros.items()]
return jsonify(result)
def valida_form_files(form, filtro, db):
"""Lê formulário e adiciona campos ao filtro se necessário."""
order = None
pagina_atual = None
if form.validate(): # configura filtro básico
numero = form.numero.data
start = form.start.data
end = form.end.data
alerta = form.alerta.data
ranking = form.ranking.data
pagina_atual = form.pagina_atual.data
filtro_escolhido = form.filtro_auditoria.data
if filtro_escolhido and filtro_escolhido != '0':
auditoria_object = Auditoria(db)
filtro_auditoria = \
auditoria_object.dict_auditoria.get(filtro_escolhido)
# logger.debug(auditoria_object.dict_auditoria)
# logger.debug(filtro_escolhido)
# logger.debug(filtro_auditoria)
if filtro_auditoria:
filtro.update(filtro_auditoria.get('filtro'))
order = filtro_auditoria.get('order')
tag_escolhida = form.filtro_tags.data
tag_usuario = form.tag_usuario.data
# print('****************************', tag_escolhida)
if tag_escolhida and tag_escolhida != '0':
filtro_tag = {'tag': tag_escolhida}
if tag_usuario:
filtro_tag.update({'usuario': current_user.id})
filtro.update({'metadata.tags': {'$elemMatch': filtro_tag}})
texto_ocorrencia = form.texto_ocorrencia.data
if texto_ocorrencia:
filtro.update({
'metadata.ocorrencias': {
'$exists': True
},
'metadata.ocorrencias.texto': {
'$regex': texto_ocorrencia
}
})
if numero == 'None':
numero = None
if start and end:
start = datetime.combine(start, datetime.min.time())
end = datetime.combine(end, datetime.max.time())
filtro['metadata.dataescaneamento'] = {'$lte': end, '$gte': start}
if numero:
filtro['metadata.numeroinformado'] = mongo_sanitizar(
numero).upper()
if alerta:
filtro['metadata.xml.alerta'] = True
if ranking:
filtro['metadata.ranking'] = {'$exists': True, '$gte': .5}
order = [('metadata.ranking', -1)]
# print(filtro)
return filtro, pagina_atual, order
def login():
"""View para efetuar login."""
message = request.args.get('message')
if request.method == 'POST':
username = mongo_sanitizar(request.form.get('username'))
# Não aceitar senha vazia!!
password = mongo_sanitizar(request.form.get('senha', '*'))
registered_user = authenticate(username, password)
if registered_user is not None:
flash('Usuário autenticado.')
login_user(registered_user)
logger.info('Usuário %s autenticou' % current_user.name)
# g['username'] = current_user.name
return redirect(url_for('index'))
else:
return abort(401)
else:
if message:
flash(message)
return render_template('login.html', form=request.form)
def get_imagens_container(mongodb, numero: str) -> list:
if numero is None or numero == '':
raise ValueError('get_imagens: Informe o número do contêiner!')
query = {
'metadata.numeroinformado': mongo_sanitizar(numero.strip()).upper(),
'metadata.contentType': 'image/jpeg'
}
projection = {
'metadata.numeroinformado': 1,
'metadata.dataescaneamento': 1
}
cursor = mongodb['fs.files'].find(query, projection)
return list(cursor)
def api_image(_id):
db = current_app.config['mongodb']
_id = mongo_sanitizar(_id)
try:
current_app.logger.warning(_id)
image = mongo_image(db, _id)
if image:
return jsonify(dict(
content=b64encode(image).decode(),
mimetype='image/jpeg'
)), 200
return jsonify({}), 404
except Exception as err:
current_app.logger.error(err, exc_info=True)
return jsonify({'msg': 'Erro inesperado: %s' % str(err)}), 400
def image():
"""Executa uma consulta no banco.
Monta um dicionário de consulta a partir dos argumentos do get.
Se encontrar registro, chama image_id.
"""
db = app.config['mongodb']
filtro = {
key: value
for key, value in mongo_sanitizar(request.args.items())
}
linha = db['fs.files'].find_one(filtro, {'_id': 1})
if linha:
return image_id(linha['_id'])
return ''
def auditoria():
"""Permite editar e gravar filtro de auditoria"""
# TODO: Passar lógica para caso de Uso ou para form e classe
# TODO: Criar perfil para acesso restrito e SANITIZAR ENTRADA
form = FormAuditoria()
select = SelectAuditoria()
auditoria = Auditoria(app.config['mongodb'])
select.filtro_auditoria.choices = auditoria.filtros_auditoria_desc
if request.method == 'POST':
if form.validate_on_submit():
filtro = json.loads(form.filtro.data)
try:
order = json.loads(form.order.data)
except JSONDecodeError as err:
order = form.order.data.split(',')
filtro = filtro.replace('function', 'XXXX')
order = order.replace('function', 'XXXX')
form.descricao.data = mongo_sanitizar(form.descricao.data)
auditoria.add_relatorio(form.id.data, filtro, order,
form.descricao.data)
flash('Filtro incluído!', 'success')
return redirect(url_for('auditoria'))
return render_template('auditoria.html', form=form, select=select)
def sanitize(cls, username, password):
"""Sanitização das entradas."""
return mongo_sanitizar(username), mongo_sanitizar(password)
def api_grid_data():
"""Executa uma consulta no banco.
Monta um dicionário de consulta a partir dos argumentos do get.
Se encontrar registro, retorna registro inteiro via JSON (metadados),
o arquivo (campo content) fica em fs.chunks e é recuperado pela view
image_id.
"""
# TODO: Refatorar conversões de/para MongoDB - dict - JSON
# (Ver Bhadrasana, tem algo feito nesse sentido)
db = current_app.config['mongodb']
result = []
try:
if request.method == 'POST':
try:
current_app.logger.info('grid_data request_data ' +
str(request.data))
if request.is_json:
request_dict = request.get_json()
else:
request_dict = request.form
current_app.logger.info(
str(type(request.json)) + str(request.json))
except Exception as err:
request_dict = {}
current_app.logger.error(str(err))
current_app.logger.error(request.data)
if isinstance(request_dict, str):
try:
request_dict = request_dict.replace('\'', '"')
request_dict = json.loads(request_dict)
except Exception as err:
request_dict = {}
current_app.logger.error(str(err))
query = request_dict['query']
projection = request_dict.get('projection')
query_processed = {}
for key, value in query.items():
if isinstance(value, dict):
value_processed = {}
for key2, value2 in value.items():
if isinstance(value2, str):
try:
value_processed[key2] = \
datetime.datetime.strptime(value2,
'%Y-%m-%d %H:%M:%S')
except Exception: # TODO: See specific exception
value_processed[key2] = mongo_sanitizar(value2)
else:
value_processed[key2] = value2
query_processed[key] = value_processed
else:
try:
query_processed[key] = \
datetime.datetime.strptime(value, '%Y-%m-%d %H:%M:%S')
except Exception:
query_processed[key] = mongo_sanitizar(value)
current_app.logger.info(query)
current_app.logger.info(query_processed)
current_app.logger.info(projection)
# TODO: limit and skip
linhas = db['fs.files'].find(query_processed,
projection).limit(1000)
result = list(linhas)
# current_app.logger.warning(result)
# print(result)
for linha in result:
converte_ids(linha)
# print(result)
else:
current_app.logger.warning(
'Filtro %s' %
{key: value
for key, value in request.args.items()})
filtro = {
mongo_sanitizar(key): mongo_sanitizar(value)
for key, value in request.args.items()
}
current_app.logger.warning('Filtro %s' % filtro)
linhas = db['fs.files'].find(filtro).limit(1000)
for linha in linhas:
result.append({
'_id':
str(linha['_id']),
'contentType':
str(linha['metadata'].get('contentType'))
})
if len(result) > 0:
return jsonify(result), 200
return jsonify({}), 404
except Exception as err:
current_app.logger.error(err, exc_info=True)
current_app.logger.error(request.data)
return jsonify({'msg': 'Erro: %s' % err}), 400
def api_summary(ce_mercante):
"""Fornece um sumário dos dados para visualização."""
db = current_app.config['mongodb']
loader = CargaLoader()
ce_mercante = mongo_sanitizar(ce_mercante)
# print('Consultando CE-Mercante %s' % ce_mercante)
try:
cursor = db.fs.files.find(
{'metadata.carga.conhecimento.conhecimento': ce_mercante})
summary = []
registro_pai = OrderedDict()
# print('Consultou!!!')
ind = 0
for linha in cursor:
metadata = linha.get('metadata')
carga = metadata.get('carga')
predictions = metadata.get('predictions')
carga_load = loader.load_from_gridfs(linha)
if ind == 0:
manifesto = carga_load.manifestos[0]
registro_pai['Manifesto Mercante'] = manifesto.manifesto
registro_pai['Tipo Manifesto'] = manifesto.tipomanifesto
conhecimento = carga.get('conhecimento')
if isinstance(conhecimento, list):
conhecimento = conhecimento[0]
registro_pai['NIC CE Mercante'] = conhecimento.get(
'conhecimento')
registro_pai['Tipo CE Mercante'] = conhecimento.get('tipo')
registro_pai['Descricao mercadoria CE Mercante'] = \
conhecimento.get('descricaomercadoria')
if manifesto.tipomanifesto != 'lce':
registro_pai['Consignatario carga'] = \
'%s - %s ' % (conhecimento.get('cpfcnpjconsignatario'),
conhecimento.get('nomeconsignatario'))
ind = 1
registro = OrderedDict()
registro['imagem'] = str(linha['_id'])
registro['Numero Container'] = metadata.get('numeroinformado')
try:
registro['Data Escaneamento'] = datetime.datetime.strftime(
metadata.get('dataescaneamento'), '%d/%m/%Y %H:%M')
except Exception as err:
current_app.logger.error(err, exc_info=True)
registro['Data Escaneamento'] = str(err)
if predictions:
peso = predictions[0].get('peso')
if peso and isinstance(peso, float):
registro['Peso estimado imagem'] = '{:0.2f}'.format(peso)
conteiner = carga.get('container')
if isinstance(conteiner, list):
conteiner = conteiner[0]
for campo in ['taracontainer', 'pesobrutoitem', 'volumeitem']:
try:
valor_str = conteiner.get(campo, '0')
registro[campo] = float(valor_str.replace(',', '.'))
except Exception as err:
current_app.logger.error(err, exc_info=True)
registro[campo] = str(err)
registro['NCM'] = ' '.join(
set([ncm.get('ncm') for ncm in carga.get('ncm')]))
summary.append(registro)
status_code = 404
if len(summary) > 0:
status_code = 200
registro_pai['Containers'] = summary
return jsonify(registro_pai), status_code
except Exception as err:
current_app.logger.error(err, exc_info=True)
return jsonify({'msg': 'Erro inesperado: %s' % str(err)}), 400
def test_mongo_sanitizar(self):
teste = '{$where: \'atacking\': "DANGEROUS! Test. 2.53"}function();}'
esperado = 'where atacking DANGEROUS! Test. 2.53function'
resultado = mongo_sanitizar(teste)
print(resultado)
assert resultado == esperado
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 grid_data():
"""Executa uma consulta no banco.
Monta um dicionário de consulta a partir dos argumentos do get.
Se encontrar registro, retorna registro inteiro via JSON (metadados),
o arquivo (campo content) fica em fs.chunks e é recuperado pela view
image_id.
"""
# TODO: Refatorar conversões de/para MongoDB - dict - JSON (Ver Bhadrasana, tem algo feito nesse sentido)
db = app.config['mongodb']
if request.method == 'POST':
# print(request.json)
query = request.json['query']
projection = request.json['projection']
query_processed = {}
for key, value in query.items():
if isinstance(value, dict):
value_processed = {}
for key2, value2 in value.items():
try:
value_processed[key2] = datetime.strptime(
value2, '%Y-%m-%d %H:%M:%S')
except:
value_processed[key2] = mongo_sanitizar(value2)
query_processed[key] = value_processed
else:
try:
query_processed[key] = datetime.strptime(
value, '%Y-%m-%d %H:%M:%S')
except:
query_processed[key] = mongo_sanitizar(value)
# logger.warning(query)
# logger.warning(query_processed)
# query = {mongo_sanitizar(key): mongo_sanitizar(value)
# for key, value in query.items()}
# projection = {mongo_sanitizar(key): mongo_sanitizar(value)
# for key, value in projection.items()}
# logger.warning(projection)
linhas = db['fs.files'].find(query_processed, projection)
result = []
for linha in linhas:
dict_linha = {}
for key, value in linha.items():
if isinstance(value, dict):
value_processed = {}
for key2, value2 in value.items():
try:
value_processed[key2] = datetime.strptime(
value2, '%Y-%m-%d %H:%M:%S')
except:
value_processed[key2] = str(value2)
dict_linha[key] = value_processed
else:
try:
dict_linha[key] = datetime.strptime(
value, '%Y-%m-%d %H:%M:%S')
except:
dict_linha[key] = str(value)
result.append(dict_linha)
else:
filtro = {
mongo_sanitizar(key): mongo_sanitizar(value)
for key, value in request.args.items()
}
logger.warning(filtro)
linhas = db['fs.files'].find(filtro)
result = [{
'_id': str(linha['_id']),
'contentType': str(linha['metadata'].get('contentType'))
} for linha in linhas]
status_code = 404
if len(result) > 0:
status_code = 200
return jsonify(result), status_code
