def get_conteineres_semcarga_dia(diaapesquisar: datetime) -> dict:
"""Retorna contêineres do dia com metadata.carga vazio.
Pesquisa via API, não via banco diretamente
Retorna dict com numero: _id
"""
datainicial = datetime.strftime(datetime.combine(diaapesquisar, time.min), '%Y-%m-%d %H:%M:%S')
datafinal = datetime.strftime(datetime.combine(diaapesquisar, time.max), '%Y-%m-%d %H:%M:%S')
logger.info('Pesquisando contêineres sem metadata do carga entre %s e %s' %
(datainicial, datafinal))
params = {'query':
{'metadata.dataescaneamento': {'$gte': datainicial, '$lte': datafinal},
'metadata.contentType': 'image/jpeg',
'metadata.carga': {'$exists': False}
},
'projection':
{'metadata.numeroinformado': 1,
'metadata.dataescaneamento': 1}
}
r = requests.post(VIRASANA_URL + "/grid_data", json=params, verify=False)
listacc = list(r.json())
dict_numerocc = {item['metadata']['numeroinformado']: item['_id'] for item in listacc}
if dict_numerocc.get('ERRO'):
dict_numerocc.pop('ERRO')
if dict_numerocc.get(''):
dict_numerocc.pop('')
logger.info('%s imagens encontradas sem metadata do carga' % len(dict_numerocc))
return dict_numerocc
def cria_campo_pesos_carga(db, batch_size=1):
"""Cria campo com peso total informado para contêiner no CARGA.
Grava alerta se diferença entre peso declarado e peso previsto pela
análise de imagem for significativo.
"""
filtro = {'metadata.contentType': 'image/jpeg',
'metadata.carga.vazio': False,
'metadata.predictions.peso': {'$exists': True},
'metadata.carga.pesototal': {'$exists': False}}
file_cursor = db['fs.files'].find(filtro)
total = 0
processados = 0
divergentes = 0
s0 = time.time()
for linha in file_cursor.limit(batch_size):
total += 1
pesopred = linha.get('metadata').get('predictions')[0].get('peso')
pesobalanca = get_peso_balanca(linha.get('metadata').get('pesagens'))
carga = linha.get('metadata').get('carga')
_id = linha['_id']
container = carga.get('container')
if isinstance(container, list) and len(container) > 0:
container = container[0]
if container:
tara = float(container.get('taracontainer').replace(',', '.'))
peso = float(container.get('pesobrutoitem').replace(',', '.'))
pesototal = tara + peso
peso_dif = abs(pesopred - pesototal)
peso_dif_relativo = peso_dif / (pesopred + pesototal) / 2
alertapeso = (peso_dif > 2000 and peso_dif_relativo > .15) \
or peso_dif_relativo > .4
dict_update = {'metadata.carga.pesototal': pesototal,
'metadata.diferencapeso': peso_dif,
'metadata.alertapeso': alertapeso}
if pesobalanca and pesobalanca > 0.:
peso_dif2 = abs(pesobalanca - pesototal)
peso_dif_relativo2 = peso_dif2 / (pesobalanca + pesototal) / 2
alertapeso2 = (peso_dif2 > 2000 and peso_dif_relativo2 > .15) \
or peso_dif_relativo2 > .4
dict_update.update({'metadata.diferencapeso2': peso_dif2,
'metadata.alertapeso2': alertapeso2})
db['fs.files'].update_one(
{'_id': _id},
{'$set': dict_update}
)
if alertapeso:
divergentes += 1
processados += 1
elapsed = time.time() - s0
logger.info(
'Resultado cria_campo_pesos_carga. ' +
'Pesquisados: %s ' % str(total) +
'Encontrados: %s ' % str(processados) +
'Com alerta: %s ' % str(divergentes) +
'Tempo total: {:0.2f}s '.format(elapsed) +
'{:0.5f}s por registro'.format((elapsed / total) if total else 0)
)
return total
def compara_pesagens_imagens(fs_cursor, pesagens_cursor, campo_comparacao):
ind = 0
linhas_ainserir = []
if fs_cursor and len(fs_cursor) > 0:
fs_row = fs_cursor[ind]
for pesagem in pesagens_cursor:
# print(1, pesagem[campo_comparacao], fs_row['metadata']['numeroinformado'].lower())
while fs_row['metadata']['numeroinformado'].lower(
) < pesagem[campo_comparacao]:
# print(2, pesagem[campo_comparacao], fs_row['metadata']['numeroinformado'].lower())
ind += 1
if ind >= len(fs_cursor):
break
fs_row = fs_cursor[ind]
if fs_row['metadata']['numeroinformado'].lower(
) == pesagem[campo_comparacao]:
linhas_ainserir.append((fs_row['_id'], pesagem))
# Conferência do algoritmo
containers_imagens = [
row['metadata']['numeroinformado'].lower() for row in fs_cursor
]
containers_pesagens = [row[campo_comparacao] for row in pesagens_cursor]
containers_comuns = set(containers_imagens) & set(containers_pesagens)
logger.info('TOTAL DE PESAGENS COMUNS: %s' % len(containers_comuns))
return linhas_ainserir
def edita_descricao_rvf():
session = app.config.get('dbsession')
try:
descricao = request.form.get('descricao')
if descricao is None:
raise ValueError('Digite a descrição')
try:
rvf_id = request.form.get('rvf_id')
except TypeError:
raise TypeError('Informe o id do RVF')
except ValueError:
raise ValueError('Informe id do RVF somente com números')
arvf = session.query(RVF).filter(RVF.id == rvf_id).one_or_none()
if arvf is None:
return jsonify({'msg': 'RVF %s não encontrado' % rvf_id}), 404
if arvf.descricao is None:
arvf.descricao = descricao
else:
arvf.descricao = arvf.descricao + ' ' + descricao
session.add(arvf)
session.commit()
session.refresh(arvf)
logger.info(arvf.descricao)
return jsonify(arvf.dump()), 201
except Exception as err:
logger.error(err, exc_info=True)
return 'Erro! Detalhes no log da aplicação. ' + str(err), 500
def mount(self):
cursor = self.db.fs.files.find(
self.filter, self.projection
) # .limit(20000)
print('Consultando...')
logger.info('Consultando...')
self.documentos = OrderedDict()
for line in cursor:
# print(line)
conhecimentos = line['metadata']['carga']['conhecimento']
if isinstance(conhecimentos, list):
identificacao = ' '.join([
c['identificacaoembarcador'] + ' ' +
c['descricaomercadoria']
for c in conhecimentos]
)
elif isinstance(conhecimentos, str):
identificacao = conhecimentos['identificacaoembarcador'] + \
' ' + conhecimentos['descricaomercadoria']
self.documentos[line['_id']] = identificacao
logger.info('Vetorizando...')
print('Vetorizando...')
self.count_vect = CountVectorizer()
word_count_vector = self.count_vect.fit_transform(
self.documentos.values())
print('Qtde palavras:', len(self.count_vect.vocabulary_))
tfidf_transformer = TfidfTransformer(smooth_idf=True, use_idf=True)
self.word_tfidf = tfidf_transformer.fit_transform(word_count_vector)
def get_alertas_filtro(session,
form: FormFiltroAlerta) -> Tuple[List[Alerta], int]:
start = datetime.combine(form.start.data, datetime.min.time())
end = datetime.combine(form.end.data, datetime.max.time())
recinto = form.recinto.data
order = form.order.data
reverse = form.reverse.data
paginaatual = form.pagina_atual.data
filtroalerta = FiltroAlerta(start, end)
if recinto:
filtroalerta.add_campo('cod_recinto', recinto)
filtro = filtroalerta.filtro
npaginas = int(
session.query(func.count(Alerta.ID)).filter(filtro).scalar() /
ROWS_PER_PAGE) + 1
q = session.query(Alerta).filter(filtro)
if order:
if reverse:
q = q.order_by(desc(text(order)))
else:
q = q.order_by(text(order))
logger.info(str(q))
logger.info(' '.join(
[recinto, str(start),
str(end), str(order),
str(paginaatual)]))
lista_alertas = q.limit(ROWS_PER_PAGE).offset(ROWS_PER_PAGE *
(paginaatual - 1)).all()
return lista_alertas, npaginas
def gerar_arquivos_docx(db, session, documento, filename, fonte_docx_id, oid):
out_filename = '{}_{}_{}.docx'.format(
filename,
oid,
datetime.strftime(datetime.now(), '%Y-%m-%dT%H-%M-%S')
)
try:
ovr_dict = OVRDict(fonte_docx_id).get_dict(
db=db, session=session, id=oid)
except NoResultFound:
raise NoResultFound('{} {} não encontrado!'.format(
FonteDocx(fonte_docx_id), oid))
print(ovr_dict)
if isinstance(ovr_dict, list):
if len(ovr_dict) == 0:
raise NoResultFound(f'Marcas não encontradas na ovr {oid}.')
logger.info('Gerando marcas')
arquivos = []
for odict in ovr_dict:
document = get_doc_generico_ovr(odict, documento,
current_user.name)
nome_arquivo = '%s_%s.docx' % (out_filename[:-4], odict.get('nome'))
arquivos.append(nome_arquivo)
document.save(os.path.join(
get_user_save_path(), nome_arquivo))
else:
document = get_doc_generico_ovr(ovr_dict, documento,
current_user.name)
document.save(os.path.join(get_user_save_path(), out_filename))
arquivos = [out_filename]
return arquivos
def processa_classes(engine, lista_arquivos):
count_objetos = Counter()
lista_erros = []
try:
for arquivo in lista_arquivos:
logger.info('(processa_classes)Processando arquivo xml %s' %
arquivo)
xtree = ElementTree.parse(
os.path.join(mercante.MERCANTE_DIR, arquivo))
xroot = xtree.getroot()
objetos = []
for node in xroot:
classe = mercante.classes.get(node.tag)
if classe:
count_objetos[classe] += 1
objeto = classe()
objeto._parse_node(node)
objetos.append(objeto._to_dict())
df = pd.DataFrame(objetos)
df.reset_index()
df.to_sql(node.tag, engine, if_exists='append', index=False)
except Exception as err:
logger.error('Erro ocorrido no arquivo %s. %s' % (arquivo, err))
lista_erros.append(arquivo)
return count_objetos, lista_erros
def get_imagens_recortadas(db, _id):
"""Retorna recorte das bbox detectadas para a imagem _id.
Caso existam predições bbox gravadas/cacheadas nos metadados da
imagem, retorna, ao invés da imagem original completa, apenas os
recortes correspondentes a estes "bouding boxes" detectados.
"""
images = []
image = mongo_image(db, _id)
if image:
preds = db['fs.files'].find_one({
'_id': _id
}).get('metadata').get('predictions')
if preds:
for pred in preds:
bbox = pred.get('bbox')
if bbox:
try:
recorte = recorta_imagem(image, bbox, pil=True)
images.append(recorte)
except Exception as err:
logger.info('Erro em get_imagens_recortadas ' +
'Erro: %s\n bbox:%s\n imagem:%s' %
(str(err), bbox, _id),
exc_info=True)
return images
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 get_detalhes_mercante(session, ces: List[str]) -> dict:
infoces = {}
for numeroCEmercante in ces:
try:
infoces[numeroCEmercante] = get_detalhe_conhecimento(
session, numeroCEmercante)
except Exception as err:
logger.info(err)
return infoces
def ranking_grava_fsfiles(db, batch_size=1000):
"""Busca por registros no GridFS sem info de Ranking
Busca por registros no fs.files (GridFS - imagens) que não tenham metadata
assignada de ranking de interposição.
Args:
db: connection to mongo with database setted
Returns:
Número de registros atualizados
"""
filtro = FALTANTES
projection = ['metadata.carga.conhecimento.cpfcnpjconsignatario']
total = db['fs.files'].count_documents(filtro)
lista_fs = list(
db['fs.files'].find(filtro, projection=projection
).limit(batch_size)[:batch_size]
)
lista_ranking = []
for row in lista_fs:
conhecimentos = row.get('metadata').get('carga').get('conhecimento')
ranking_soma = 0.
cont_conhecimento = 0.
for conhecimento in conhecimentos:
consignatario = conhecimento.get('cpfcnpjconsignatario')
if consignatario is not None:
# print(consignatario)
cnpj_base = consignatario[:-6]
# print(cnpj_base)
ranking = dict_empresas.get(cnpj_base)
if ranking is not None:
ranking_soma = ranking_soma + ranking
cont_conhecimento += 1.
if ranking_soma > 0.:
ranking_mean = ranking_soma / cont_conhecimento
lista_ranking.append((row['_id'], ranking_mean))
logger.info(
'Resultado ranking_grava_fsfiles '
'Pesquisados %s. '
'Encontrados %s.'
% (len(lista_fs), len(lista_ranking))
)
from pymongo import WriteConcern
fsfiles_collection = db['fs.files'].with_options(
write_concern=WriteConcern(w=0)
)
for out_row in lista_ranking:
fsfiles_collection.update_one(
{'_id': out_row[0]},
{'$set': {'metadata.ranking': out_row[1]}}
)
return len(lista_ranking)
def get_lista_fma_recintos(recintos_list, datainicial, datafinal):
token = get_token_dte()
fmas_recintos = defaultdict(list)
for recinto in recintos_list:
recinto = recinto.cod_dte
lista_fma = get_lista_fma(datainicial, datafinal, recinto, token)
if lista_fma and len(lista_fma) > 0:
logger.info('%s: %s FMAs baixadas do recinto %s' %
(datainicial, len(lista_fma), recinto))
fmas_recintos[recinto].extend(lista_fma)
return fmas_recintos
def get_pendentes(session, origem, tipomovimento, limit=20000):
controle = ControleResumo.get_(session, str(origem), tipomovimento)
maxid = controle.maxid
logger.info('%s - inicio em ID %s - tipo %s' %
(origem, maxid, tipomovimento))
s = select([origem]).where(
and_(origem.c['id'] > maxid,
origem.c['tipoMovimento'] == tipomovimento)).order_by(
origem.c['id']).limit(limit)
resultproxy = session.execute(s)
return controle, resultproxy
def get_pesagens_dte_recintos(recintos_list, datainicial, datafinal):
token = get_token_dte()
pesagens_recintos = defaultdict(list)
for linha in recintos_list[1:]:
recinto = linha[0]
pesagens_recinto = get_pesagens_dte(datainicial, datafinal,
recinto, token)
if pesagens_recinto and len(pesagens_recinto) > 0:
logger.info('%s: %s pesagens baixadas do recinto %s' %
(datainicial, len(pesagens_recinto), recinto))
pesagens_recintos[recinto].extend(pesagens_recinto)
return pesagens_recintos
def get_ficha_id(ovr_id, token):
headers = {'Authorization': 'Bearer ' + token}
r = requests.get(URL_OVR + str(ovr_id), headers=headers)
logger.info('get_ovr_id ' + r.url)
try:
if r.status_code == 200:
return r.json()
raise Exception('Erro: %s' % r.status_code)
except Exception as err:
logger.error(str(type(err)) + str(err))
logger.error(r.status_code)
logger.error(r.text[:200])
def importacsv():
"""Importar arquivo com lista de DSI e CPF
"""
session = app.config.get('db_session')
lista_cpf = []
if request.method == 'POST':
try:
csvf = get_planilha_valida(request, 'planilha')
if csvf:
filename = secure_filename(csvf.filename)
save_name = os.path.join(tmpdir, filename)
csvf.save(save_name)
logger.info('CSV RECEBIDO: %s' % save_name)
if 'xlsx' in filename:
df = pd.read_excel(save_name, engine='openpyxl')
else:
df = pd.read_excel(save_name)
achou = False
# df = df.dropna()
for row in df.itertuples():
if achou is False:
if row[1] == 'DSI' and row[2] == 'CPF':
achou = True
continue
else:
logger.info('Recuperando row[1] "%s"' % row[1])
if row[1] is None:
break
dsi = ''.join([s for s in str(row[1]) if s.isdigit()])
cpf = ''.join([s for s in str(row[2]) if s.isdigit()])
if not dsi:
break
lista_cpf.append(cpf)
logger.info('Recuperando dsi "%s"' % dsi)
adsi = session.query(DSI).filter(DSI.numero == dsi).one_or_none()
if adsi is None:
adsi = DSI()
logger.info('Recuperando mercante cpf %s' % cpf)
ocemercante = session.query(Conhecimento).filter(Conhecimento.consignatario == cpf). \
order_by(Conhecimento.dataEmissao.desc()).first()
adsi.numero = dsi
adsi.consignatario = cpf
if ocemercante is not None:
adsi.numeroCEmercante = ocemercante.numeroCEmercante
adsi.data_registro = datetime.today()
session.add(adsi)
logger.info('Salvando %s dsis' % len(lista_cpf))
session.commit()
except Exception as err:
logger.error(str(err), exc_info=True)
flash(str(err))
inicio = datetime.strftime(datetime.today() - timedelta(days=120), '%Y-%m-%d')
return redirect('bagagens_redirect?filtrar_dsi=1&cpf_cnpj=%s&start=%s' % (';'.join(lista_cpf), inicio))
def processa_resumo(engine, origem, destino, chaves):
Session = sessionmaker(bind=engine)
session = Session()
# Fazer INSERTS PRIMEIRO
movimentos = ['I', 'A', 'E']
for tipomovimento in movimentos:
controle, resultproxy = get_pendentes(session, origem, tipomovimento)
campos_destino = monta_campos(destino)
# Tratar atualização de EscalaManifesto como inclusão
if destino.__name__ == 'EscalaManifesto':
if tipomovimento == 'A':
tipomovimento = 'I'
cont = 0
for row in resultproxy:
if row['id'] > controle.maxid:
controle.maxid = row['id']
dict_campos = {key: row[key] for key in campos_destino}
chaves_valores = [
getattr(destino, chave) == row[chave] for chave in chaves
]
# print(chaves_valores)
if tipomovimento == 'I':
try:
existe = session.query(destino).filter(
*chaves_valores).one_or_none()
except MultipleResultsFound:
continue
if existe:
continue
objeto = destino(**dict_campos)
session.add(objeto)
# destino.__table__.insert().prefix_with('IGNORE').values(**dict_campos)
cont += 1
else: # A = Update / E = Delete
try:
objeto = session.query(destino).filter(
*chaves_valores).one_or_none()
if objeto:
cont += 1
if tipomovimento == 'E':
session.delete(objeto)
else:
for k, v in dict_campos.items():
setattr(objeto, k, v)
except MultipleResultsFound:
filtro = {chave: row[chave] for chave in chaves}
logger.error(
'Erro! Multiplos registros encontrados para %s com filtro %s'
'Registro %s não atualizado!' %
(destino.__tablename__, filtro, row['id']))
session.add(controle)
session.commit()
logger.info('%s Resumos tipo %s processados' % (cont, tipomovimento))
def periodic_updates(db, connection, lote=2000):
print('Iniciando atualizações...')
hoje = datetime.combine(date.today(), datetime.min.time())
doisdias = hoje - timedelta(days=2)
cincodias = hoje - timedelta(days=5)
dezdias = hoje - timedelta(days=10)
vintedias = hoje - timedelta(days=20)
ontem = hoje - timedelta(days=1)
xmli.dados_xml_grava_fsfiles(db, lote * 5, cincodias)
logger.info('Pegando arquivos XML')
processa_xml_mercante.get_arquivos_novos(connection)
processa_xml_mercante.xml_para_mercante(connection)
resume_mercante.mercante_resumo(connection)
mercante_fsfiles.update_mercante_fsfiles_dias(db, connection, hoje, 10)
# carga.dados_carga_grava_fsfiles(db, lote * 2, doisdias)
anomalia_lote.processa_zscores(db, cincodias, ontem)
info_ade02.adquire_pesagens(db, cincodias, ontem)
info_ade02.pesagens_grava_fsfiles(db, cincodias, ontem)
atualiza_stats(db)
carga.cria_campo_pesos_carga(db, lote * 3)
carga.cria_campo_pesos_carga_pesagem(db, lote * 3)
# predictions_update2('ssd', 'bbox', lote, 4)
try:
print('TFS desligado...')
# predictions_update2('index', 'index', lote, 8)
except Exception as err:
logger.error(err, exc_info=True)
# gera_indexes()
# print(reload_indexes())
# tfs_predictions_update('vazio', lote, 20)
try:
# tfs_predictions_update('peso', lote, 20)
print('TFS desligado...')
except Exception as err:
logger.error(err, exc_info=True)
# predictions_update2('vaziosvm', 'vazio', lote, 4)
# predictions_update2('peso', 'peso', lote, 16)
try:
jupapi.novas_gmcis(connection)
except Exception as err:
logger.error(err, exc_info=True)
try:
conformidadeupdate.update_conformidade(db, connection)
# Depois de dez dias, desiste de atualizar os campos extras puxados do bbox
conformidadeupdate.preenche_bbox(db, connection, start=dezdias)
# Depois de vinte dias, desiste de atualizar os campos extras puxados do Carga
conformidadeupdate.completa_conformidade(db,
connection,
start=vintedias)
conformidadeupdate.preenche_isocode(db, connection, start=vintedias)
except Exception as err:
logger.error(err, exc_info=True)
def completa_conformidade(db, engine, limit=2000, start=None):
Session = sessionmaker(bind=engine)
session = Session()
if start:
lista_conformidade = session.query(Conformidade) \
.filter(Conformidade.dataescaneamento >= start) \
.filter(Conformidade.tipotrafego.is_(None)).limit(limit).all()
else:
lista_conformidade = session.query(Conformidade) \
.filter(Conformidade.tipotrafego.is_(None)).limit(limit).all()
tempo = time.time()
qtde = 0
try:
for conformidade in lista_conformidade:
row = db['fs.files'].find_one(
{'_id': ObjectId(conformidade.id_imagem)})
tipotrafego = None
vazio = None
paisdestino = None
metadata = row['metadata']
carga = metadata.get('carga')
if carga:
conhecimento = carga.get('conhecimento')
if conhecimento:
if isinstance(conhecimento, list):
conhecimento = conhecimento[0]
tipotrafego = conhecimento.get('trafego')
if tipotrafego:
vazio = False
paisdestino = conhecimento.get('paisdestino')
else:
manifesto = carga.get('manifesto')[0]
tipotrafego = manifesto.get('trafego')
vazio = True
if tipotrafego == 'lce':
paisdestino = manifesto.get(
'codigoportodescarregamento')[:2]
conformidade.tipotrafego = tipotrafego
conformidade.vazio = vazio
conformidade.paisdestino = paisdestino
session.add(conformidade)
session.commit()
qtde += 1
except Exception as err:
logger.error(err, exc_info=True)
session.rollback()
tempo = time.time() - tempo
tempo_registro = 0 if (qtde == 0) else (tempo / qtde)
logger.info(
f'{qtde} análises de conformidade complementadas em {tempo} segundos.'
+ f'{tempo_registro} por registro')
def cria_campo_pesos_carga_pesagem(db, batch_size=1000):
"""Grava alerta se diferença entre peso declarado e peso pesado pela
balança for significativo.
"""
filtro = {
'metadata.contentType': 'image/jpeg',
'metadata.carga.pesototal': {
'$exists': True
},
'metadata.pesagens.peso': {
'$exists': True
},
'metadata.pesagens.tara': {
'$exists': True
},
'metadata.alertapeso2': {
'$exists': False
}
}
file_cursor = db['fs.files'].find(filtro)
total = 0
processados = 0
divergentes = 0
s0 = time.time()
for linha in file_cursor.limit(batch_size):
_id = linha['_id']
total += 1
pesobalanca = get_peso_balanca(linha.get('metadata').get('pesagens'))
pesototal = linha.get('metadata').get('carga').get('pesototal')
if pesobalanca and pesobalanca > 0.:
peso_dif2 = abs(pesobalanca - pesototal)
peso_dif_relativo2 = peso_dif2 / (pesobalanca + pesototal) / 2
alertapeso2 = (peso_dif2 > 2000 and peso_dif_relativo2 > .15) \
or peso_dif_relativo2 > .4
dict_update = {
'metadata.diferencapeso2': peso_dif2,
'metadata.alertapeso2': alertapeso2
}
db['fs.files'].update_one({'_id': _id}, {'$set': dict_update})
if alertapeso2:
divergentes += 1
processados += 1
elapsed = time.time() - s0
logger.info('Resultado cria_campo_pesos_carga_pesagem. ' +
'Pesquisados: %s ' % str(total) +
'Encontrados: %s ' % str(processados) +
'Com alerta: %s ' % str(divergentes) +
'Tempo total: {:0.2f}s '.format(elapsed) +
'{:0.5f}s por registro'.format((elapsed /
total) if total else 0))
return total
def pesquisa_containers_no_mercante(engine, dia: datetime,
listanumerocc: list):
if len(listanumerocc) == 0:
return {}, {}
before = dia - timedelta(days=6)
before = datetime.strftime(before, '%Y-%m-%d')
today = datetime.strftime(dia, '%Y-%m-%d')
after = dia + timedelta(days=10)
after = datetime.strftime(after, '%Y-%m-%d')
# Pesquisar importação (5) e exportação (7)
parametros_pesquisas = [(5, before, today), (7, today, after)]
manifestos = defaultdict(set)
conhecimentos = defaultdict(set)
STEP = 400
for r in range((len(listanumerocc) // STEP) + 1):
start = r * STEP
listaparcial = listanumerocc[start:start + STEP]
lista = '("' + '", "'.join(sorted(listaparcial)) + '")'
print(lista)
sql_manifestos = \
'SELECT numero, idConteinerVazio FROM conteinervazioresumo c ' \
' inner join manifestosresumo m on c.manifesto = m.numero' \
' where tipoTrafego = %s AND ' \
' dataInicioOperacaoDate >= %s AND dataInicioOperacaoDate <= %s AND ' \
' c.idConteinerVazio IN ' + lista
sql_conhecimentos = \
'SELECT c.numeroCEmercante, codigoConteiner FROM itensresumo i' \
' inner join conhecimentosresumo c on i.numeroCEmercante = c.numeroCEmercante' \
' inner join manifestosresumo m on c.manifestoCE = m.numero' \
' WHERE c.tipoBLConhecimento in (\'10\', \'11\', \'12\') AND' \
' m.tipoTrafego = %s AND' \
' dataInicioOperacaoDate >= %s AND dataInicioOperacaoDate <= %s AND ' \
' i.codigoConteiner IN ' + lista
with engine.connect() as conn:
conn.execute(sqlalchemy.sql.text(UPDATE_DATAOPERACAO_SQL))
for parametros_pesquisa in parametros_pesquisas:
cursor = conn.execute(sql_manifestos, parametros_pesquisa)
result = cursor.fetchall()
logger.info('%s Manifestos encontrados para parâmetros %s' %
(len(result), parametros_pesquisa))
for linha in result:
manifestos[linha['idConteinerVazio']].add(linha['numero'])
cursor = conn.execute(sql_conhecimentos, parametros_pesquisa)
result = cursor.fetchall()
logger.info('%s Conhecimentos encontrados para parâmetros %s' %
(len(result), parametros_pesquisa))
for linha in result:
conhecimentos[linha['codigoConteiner']].add(
linha['numeroCEmercante'])
return manifestos, conhecimentos
def espera_resposta(api_url, bson_file, sleep_time=10, timeout=180):
"""Espera resposta da task.
Espera resposta da task que efetivamente carregará o arquivo no
Banco de Dados do Servidor.
Recebendo uma resposta positiva, exclui arquivo enviado do disco.
Recebendo uma resposta negativa, grava no logger.
Args:
api_url: endereço para acesso aos dados da task
bson_file: caminho completo do arquivo original que foi enviado
sleep_time: tempo entre requisições ao Servidor em segundos
timeout: tempo total para aguardar resposta, em segundos
"""
enter_time = time.time()
rv = None
try:
while True:
time.sleep(sleep_time)
if time.time() - enter_time >= timeout:
logger.error('Timeout ao esperar resultado de processamento ' +
'Funcao: espera_resposta' + ' Arquivo: ' +
bson_file)
return False
rv = requests.get(api_url)
if rv and rv.status_code == 200:
try:
response_json = rv.json()
state = response_json.get('state')
if state and state in states.SUCCESS:
os.remove(bson_file)
logger.info('Arquivo ' + bson_file + ' removido.')
return True
if state and state in states.FAILURE:
logger.error(rv.text)
return False
except json.decoder.JSONDecodeError as err:
logger.error(err, exc_info=True)
logger.error(rv.text)
return False
except Exception as err:
logger.error(err, exc_info=True)
print(err)
return False
def update_conformidade(db, engine, start=None, end=None, limit=2000):
Session = sessionmaker(bind=engine)
session = Session()
if start is None:
start = session.query(func.max(Conformidade.uploadDate)).scalar()
if end is None:
end = datetime.datetime.combine(datetime.datetime.now(),
datetime.time.max)
tempo = time.time()
query = {
'metadata.contentType': 'image/jpeg',
'uploadDate': {
'$gte': start,
'$lte': end
}
}
logger.info(query)
cursor = db['fs.files'].find(query).limit(limit)
qtde = 0
for linha in cursor:
image_bytes = mongo_image(db, linha['_id'])
# print(image_bytes)
try:
image = Image.open(io.BytesIO(image_bytes))
conformidade = Conformidade()
conformidade.set_size(image.size)
conformidade.cod_recinto = linha['metadata']['recinto']
conformidade.uploadDate = linha['uploadDate']
conformidade.id_imagem = str(linha['_id'])
conformidade.dataescaneamento = linha['metadata'][
'dataescaneamento']
conformidade.numeroinformado = linha['metadata']['numeroinformado']
session.add(conformidade)
session.commit()
qtde += 1
except UnicodeDecodeError:
logger.error(f'Erro de encoding no id: {linha["_id"]}')
except PIL.UnidentifiedImageError:
logger.error(f'Erro de imagem no id: {linha["_id"]}')
except IntegrityError:
session.rollback()
logger.error(f'Linha duplicada: {linha["_id"]}')
tempo = time.time() - tempo
tempo_registro = 0 if (qtde == 0) else (tempo / qtde)
logger.info(
f'{qtde} análises de conformidade inseridas em {tempo} segundos.' +
f'{tempo_registro} por registro')
def login():
"""Endpoint para efetuar login (obter token)."""
if not request.json or not request.is_json:
return jsonify({"msg": "JSON requerido"}), 400
username = request.json.get('username', None)
password = request.json.get('password', None)
if not username:
return jsonify({"msg": "Parametro username requerido"}), 400
if not password:
return jsonify({"msg": "Parametro password requerido"}), 400
user = verify_password(username, password)
if user is None:
return jsonify({"msg": "username ou password invalidos"}), 401
logger.info('Entrando com usuário %s' % username)
access_token = create_access_token(identity=user.id)
return jsonify(access_token=access_token), 200
def comunicado_contrafacao():
print(request.url)
session = app.config['dbsession']
db = app.config['mongo_risco']
ovr_id = request.args.get('ovr_id')
representante_id = request.args.get('representante_id')
try:
usuario = get_usuario(session, current_user.name)
if usuario is None:
raise Exception('Erro: Usuário não encontrado!')
if ovr_id:
try:
ovr_dicts = OVRDict(FonteDocx.Marcas).get_dict(
db=db, session=session, id=ovr_id)
except NoResultFound:
raise NoResultFound(f'Marcas não encontradas para Ficha {ovr_id}.')
if len(ovr_dicts) == 0:
raise NoResultFound(f'Marcas não encontradas na ovr {ovr_id}.')
logger.info('Gerando marcas')
document = None
representante_id2 = None
for ovr_dict in ovr_dicts:
representante_id2 = ovr_dict.get('representante_id')
representante_nome = ovr_dict.get('representante_nome')
if representante_id2 and (str(representante_id2) == representante_id):
document = gera_comunicado_contrafacao(ovr_dict, current_user.name,
'termo' in request.url)
break
if representante_id2 and document:
nome = 'Comunicado_de_Contrafacao'
if 'termo' in request.url:
nome = 'Termo de retirada de amostras'
out_filename = '{}_{}_{}_{}.docx'.format(
nome,
ovr_id,
representante_nome,
datetime.strftime(datetime.now(), '%Y-%m-%dT%H-%M-%S')
)
document.save(os.path.join(
get_user_save_path(), out_filename))
return redirect('static/%s/%s' % (current_user.name, out_filename))
except Exception as err:
logger.error(err, exc_info=True)
flash('Erro! Detalhes no log da aplicação.')
flash(str(type(err)))
flash(str(err))
return redirect(url_for('autos_contrafacao', ovr_id=ovr_id))
def get_lista_fma(start, end, cod_recinto, token):
payload = {
'data_inicio': datetime.strftime(start, '%Y-%m-%d'),
'data_fim': datetime.strftime(end, '%Y-%m-%d'),
'cod_recinto': cod_recinto
}
headers = {'Authorization': 'Bearer ' + token}
r = requests.get(DTE_URL_FMA, headers=headers, params=payload)
logger.info('get_fma_dte ' + r.url)
try:
lista_fma = r.json()['JUP_WS']['FMA_Eletronica']['Lista_FMA']
except Exception as err:
logger.error(str(type(err)) + str(err))
logger.error(r.status_code)
logger.error(r.text)
return None
return lista_fma
def get_detalhe_conhecimento(session, numeroCEmercante: str) -> dict:
linha = dict()
conhecimento = get_conhecimento(session, numeroCEmercante)
linha['conhecimento'] = conhecimento
linha['containers'] = get_containers_conhecimento(session,
numeroCEmercante)
linha['filhotes'] = get_conhecimentos_filhotes(session, numeroCEmercante)
linha['ncms'] = get_ncms_conhecimento(session, numeroCEmercante)
logger.info('get_laudos')
if conhecimento:
cnpj = conhecimento.consignatario
if cnpj:
empresa = get_empresa(session, cnpj)
sats = get_sats_cnpj(session, cnpj)
linha['empresa'] = empresa
linha['sats'] = sats
return linha
def get_lista_ovr(start, end, user_name, token):
payload = {'datahora': datetime.strftime(start, '%Y-%m-%d'),
'data_fim': datetime.strftime(end, '%Y-%m-%d'), }
payload = {'user_name': user_name}
headers = {'Authorization': 'Bearer ' + token}
r = requests.post(URL_OVRS, headers=headers, json=payload)
logger.info('get_lista_ovr ' + r.url)
try:
if r.status_code == 200:
lista_ovrs = r.json()
else:
raise Exception('Erro: %s' % r.status_code)
except Exception as err:
logger.error(str(type(err)) + str(err))
logger.error(r.status_code)
logger.error(r.text)
return None
return lista_ovrs
def get_arquivos_novos(engine, start=None, days=1):
"""Baixa arquivos novos da API do Aniita"""
if start is None:
data_ultimo_arquivo = data_ultimo_arquivo_baixado(engine)
else:
data_ultimo_arquivo = start
datainicial = datetime.strftime(data_ultimo_arquivo + timedelta(seconds=1),
FORMATO_DATA_ANIITA)
datafinal = datetime.strftime(data_ultimo_arquivo + timedelta(days=days),
FORMATO_DATA_ANIITA)
print(datainicial, datafinal)
r = requests.get(URL_ANIITA_LISTA,
params={
'dtInicial': datainicial,
'dtFinal': datafinal
})
logger.info(r.url)
logger.info(r.text)
try:
if r.status_code == 200:
lista_arquivos = r.json()
for item in lista_arquivos:
filename = item['nomeArquivo']
r = requests.get(URL_ANIITA_DOWNLOAD,
params={'nome': filename})
logger.info(r.url)
destino = os.path.join(mercante.MERCANTE_DIR, filename)
logger.info('Gerando arquivo %s' % destino)
if r.status_code == 200:
with open(destino, 'wb') as out:
out.write(r.content)
# Grava em tabela arquivos baixados
ind_partedata = filename.rfind('_', ) + 1
partedata = filename[ind_partedata:-4]
logger.info(partedata)
try:
data = datetime.strptime(partedata,
FORMATO_DATA_ARQUIVO)
grava_arquivo_baixado(engine, filename, data)
except ValueError as err:
logger.error(err)
except JSONDecodeError as err:
logger.error(err)