示例#1
0
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')
示例#2
0
    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
示例#3
0
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')
示例#4
0
    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
示例#5
0
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))
示例#6
0
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
示例#7
0
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))
示例#8
0
 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
示例#9
0
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
示例#10
0
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)
示例#11
0
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
示例#12
0
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)
示例#13
0
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)
示例#14
0
 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()
示例#15
0
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)
示例#16
0
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({})
示例#17
0
    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)
示例#18
0
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)
示例#19
0
 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
示例#21
0
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
示例#22
0
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
示例#24
0
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)
示例#25
0
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
示例#27
0
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)
示例#28
0
 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())