def aplicar_risco_mongo(self, visaoid, padraoid, parametros_ativos, dest_path):
"""Chama função de aplicação de risco e grava resultado em arquivo."""
mensagem = 'Aguarde. Aplicando risco no MongoDB. Visão: ' + visaoid
self.update_state(state=states.STARTED, meta={'status': mensagem})
mysession = MySession(Base)
dbsession = mysession.session
conn = MongoClient(host=MONGODB_URI)
db = conn[DATABASE]
gerente = GerenteRisco()
try:
self.update_state(state=states.PENDING, meta={'status': mensagem})
lista_risco = gerente.aplica_risco_por_parametros(
dbsession,
visaoid=visaoid,
padraoid=padraoid,
parametros_ativos=parametros_ativos,
base_csv=None,
db=db)
if lista_risco:
csv_salvo = os.path.join(
dest_path,
datetime.today().strftime('%Y-%m-%d-%H:%M:%S') + '.csv')
gerente.save_csv(lista_risco, csv_salvo)
return {'status': 'Planilha criada com sucesso a partir do MongoDB'}
except Exception as err:
logger.error(err, exc_info=True)
self.update_state(state=states.FAILURE, meta={'status': str(err)})
def arquiva_base_csv(self, baseid, base_csv):
"""Copia CSVs para MongoDB e apaga do disco."""
# Aviso: Esta função rmtree só deve ser utilizada com caminhos seguros,
# de preferência gerados pela própria aplicação
self.update_state(state=states.STARTED,
meta={'status': 'Aguarde. Arquivando base ' + base_csv})
mysession = MySession(Base)
dbsession = mysession.session
try:
abase = dbsession.query(BaseOrigem).filter(
BaseOrigem.id == baseid).first()
self.update_state(state=states.PENDING,
meta={
'status':
'Aguarde... arquivando base ' + base_csv +
' na base MongoDB ' + abase.nome
})
conn = MongoClient(host=MONGODB_URI)
db = conn[DATABASE]
GerenteRisco.csv_to_mongo(db, abase, base_csv)
shutil.rmtree(base_csv)
return {'status': 'Base arquivada com sucesso'}
except Exception as err:
logger.error(err, exc_info=True)
self.update_state(state=states.FAILURE, meta={'status': str(err)})
def aplicar_risco(self, base_csv: str, padraoid: int, visaoid: int,
parametros_ativos: list, dest_path: str):
"""Chama função de aplicação de risco e grava resultado em arquivo."""
mensagem = 'Aguarde. Aplicando risco na base ' + \
'-'.join(base_csv.split('/')[-3:])
self.update_state(state=states.STARTED, meta={'status': mensagem})
mysession = MySession(Base)
dbsession = mysession.session
gerente = GerenteRisco()
try:
self.update_state(state=states.PENDING, meta={'status': mensagem})
lista_risco = gerente.aplica_risco_por_parametros(
dbsession,
padraoid=padraoid,
visaoid=visaoid,
parametros_ativos=parametros_ativos,
base_csv=base_csv)
if lista_risco:
csv_salvo = os.path.join(
dest_path,
datetime.today().strftime('%Y-%m-%d-%H:%M:%S') + '.csv')
gerente.save_csv(lista_risco, csv_salvo)
return {'status': 'Planilha criada com sucesso'}
except Exception as err:
logger.error(str(err), exc_info=True)
self.update_state(state=states.FAILURE, meta={'status': str(err)})
def setUp(self):
mysession = MySession(Base, test=True)
self.session = mysession.session
self.engine = mysession.engine
Base.metadata.create_all(self.engine)
self.tmpdir = tempfile.mkdtemp()
# Ensure the file is read/write by the creator only
self.saved_umask = os.umask(0o077)
def importar_base(self, csv_folder, baseid, data, filename, remove=False):
"""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)
Ver também :func: `bhadrasana.app.importa_base`
Args:
csv_folder: caminho onde será salvo o resultado
abase: Base de Origem do arquivo
data: data inicial do período extraído (se não for passada,
assume hoje)
filename: arquivo csv, sch+txt, ou conjunto deles em formato zip
remove: exclui arquivo original no final do processamento
"""
self.update_state(
state=states.STARTED,
meta={'status': 'Processando arquivo ' + filename + '. Aguarde!!!'})
basefilename = os.path.basename(filename)
print(basefilename)
mysession = MySession(Base)
dbsession = mysession.session
gerente = GerenteRisco()
try:
abase = dbsession.query(BaseOrigem).filter(
BaseOrigem.id == baseid).first()
self.update_state(state=states.PENDING,
meta={
'status':
'Processando arquivo ' + basefilename +
' na base ' + abase.nome + '. Aguarde!!!'
})
lista_arquivos = gerente.importa_base(csv_folder, baseid, data,
filename, remove)
# Sanitizar base já na importação para evitar
# processamento repetido depois
gerente.ativa_sanitizacao(ascii_sanitizar)
gerente.checa_depara(abase) # Aplicar na importação???
gerente.pre_processa_arquivos(lista_arquivos)
return {'status': 'Base ' + data + ' importada com sucesso'}
except Exception as err:
logger.error(err, exc_info=True)
self.update_state(state=states.FAILURE, meta={'status': str(err)})
def arquiva_base_csv_sync(baseid, base_csv):
"""Copia CSVs para MongoDB e apaga do disco."""
# Aviso: Esta função rmtree só deve ser utilizada com caminhos seguros,
# de preferência gerados pela própria aplicação
mysession = MySession(Base)
dbsession = mysession.session
try:
abase = dbsession.query(BaseOrigem).filter(
BaseOrigem.id == baseid).first()
conn = MongoClient(host=MONGODB_URI)
db = conn[DATABASE]
GerenteRisco.csv_to_mongo(db, abase, base_csv)
shutil.rmtree(base_csv)
return 'Base arquivada com sucesso'
except Exception as err:
logger.error(err, exc_info=True)
return str(err)
def create_app(self):
"""Requisito do LiveServerTestCase. Retorna aplicação a ser testada.
Está sendo criado um BD de testes, na memória.
Deve-ser tomar cuidado ao modificar, pois a classe recria e APAGA
o BD dbsession a cada teste.
"""
mysession = MySession(Base, test=True)
self.dbsession = mysession.session
self.engine = mysession.engine
# print('####################################### CREATE DATABASE')
Base.metadata.create_all(self.engine)
create_base_testes(self.dbsession)
conn = MongoClient(host=MONGODB_URI)
self.mongodb = conn[DATABASE]
app = AppSingleTon.create(self.dbsession, self.mongodb)
DBUser.dbsession = None # Bypass authentication
app.config.update(
LIVESERVER_PORT=8942
)
return app
# Interpret the config file for Python logging.
# This line sets up loggers basically.
fileConfig(config.config_file_name)
# add your model's MetaData object here
# for 'autogenerate' support
# from myapp import mymodel
# target_metadata = mymodel.Base.metadata
target_metadata = None
# other values from the config, defined by the needs of env.py,
# can be acquired:
# my_important_option = config.get_main_option("my_important_option")
# ... etc.
mysession = MySession(Base)
session = mysession.session
engine = mysession.engine
target_metadata = Base.metadata
def run_migrations_offline():
"""Run migrations in 'offline' mode.
This configures the context with just a URL
and not an Engine, though an Engine is acceptable
here as well. By skipping the Engine creation
we don't even need a DBAPI to be available.
Calls to context.execute() here emit the given string to the
script output.
print(de_para_dict)
# TODO: Fazer planilha COV "FAKE" com títulos reais
# e linha de dados
lista_nova = muda_titulos_csv(CSV_TITLES_TEST, de_para_dict)
lista_old = [[
'nome motorista', 'cpf motorista', 'descricao ncm',
'razao social exportador / importador',
'cnpj exportador / importador', 'nome operador scanner',
'cpf operador scanner', 'cnpj transportadora'
], ['dado1c1', 'dado1c2']]
lista = muda_titulos_lista(lista_old, de_para_dict)
print(lista_nova[0])
print('lista')
print(lista[0])
for old, new in de_para_dict.items():
assert old in ''.join(lista_old[0])
assert new not in ''.join(lista_old[0])
for old, new in de_para_dict.items():
assert new in ''.join(lista_nova[0])
if __name__ == '__main__':
# Cria no banco atualmente configurado os objetos de teste
# Apenas para praticidade durante o período inicial de testes
mysession = MySession(Base, test=False)
dbsession = mysession.session
print('Atenção, entrando em Base REAL!!!!')
# gerente = GerenteRisco()
# gerente.import_named_csv(CSV_NAMEDRISCO_TEST, session=mysession.session)
# gerente.cria_base('PLANILHA_COV', session=mysession.session)
def setUp(self):
mysession = MySession(Base, test=True)
self.session = mysession.session
self.engine = mysession.engine
Base.metadata.create_all(self.engine)
"""Arquivo temporário para testes exploratórios com novos métodos MongoDB."""
from pymongo import MongoClient
from bhadrasana.models.models import Base, MySession, PadraoRisco, Visao
from bhadrasana.utils.gerente_risco import GerenteRisco
gerente = GerenteRisco()
mysession = MySession(Base, test=False).session
db = MongoClient()['test']
visao = mysession.query(Visao).filter(Visao.id == 1).first()
padrao = mysession.query(PadraoRisco).filter(PadraoRisco.id == 1).first()
gerente.set_padraorisco(padrao)
df = gerente.aplica_juncao_mongo(db,
visao,
parametros_ativos=['cpfcnpjconsignatario'],
filtrar=True,
pandas=False)
print(df)
filtro = {
'$or': [{
'alimento': {
'$in': ['bacon', 'coxinha', 'frutose', 'dextrose de milho']
}
}, {
'esporte': {
'$in': ['basejump', 'surf', 'ufc', 'escalada']
}
}]
}
"""