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)