def busca_dados_cloud(params_exec):
print('- Iniciando busca de dados no cloud.')
registros = interacao_cloud.busca_dados_cloud(params_exec, url=url)
print(
f'- Foram encontrados {len(registros)} registros cadastrados no cloud.'
)
registros_formatados = []
try:
for item in registros:
hash_chaves = model.gerar_hash_chaves(sistema, tipo_registro,
item['nome'])
registros_formatados.append({
'sistema': sistema,
'tipo_registro': tipo_registro,
'hash_chave_dsk': hash_chaves,
'descricao_tipo_registro': 'Cadastro de Paises',
'id_gerado': item['id'],
'i_chave_dsk1': item['nome'],
})
model.insere_tabela_controle_migracao_registro(
params_exec, lista_req=registros_formatados)
print(
f'- Busca de {tipo_registro} finalizada. Tabelas de controles atualizas com sucesso.'
)
except Exception as error:
print(f'Erro ao executar função "busca_dados_cloud". {error}')
def busca_dados_cloud(params_exec, dados_assunto):
print('- Iniciando busca de dados no cloud.')
registros = interacao_cloud.busca_dados_cloud(params_exec, url=url)
registros_formatados = []
print(
f'- Foram encontrados {len(registros)} registros cadastrados no cloud.'
)
try:
for item in registros:
df_matches = dados_assunto.loc[dados_assunto['tctdescricao'].values
== item['descricao']]
if not df_matches.empty:
chave_dsk1 = str(df_matches['tctcodigo'].values[0])
hash_chaves = model.gerar_hash_chaves(sistema, tipo_registro,
chave_dsk1)
novo_registro = {
'sistema': sistema,
'tipo_registro': tipo_registro,
'hash_chave_dsk': hash_chaves,
'descricao_tipo_registro': 'Cadastro de Tipos de Ato',
'id_gerado': item['id'],
'i_chave_dsk1': chave_dsk1
}
registros_formatados.append(novo_registro)
# print('novo_registro', item['descricao'], novo_registro)
model.insere_tabela_controle_migracao_registro(
params_exec, lista_req=registros_formatados)
except Exception as error:
print(f'Erro ao executar função "busca_dados_cloud". {error}')
def busca_dados_cloud(params_exec):
print('- Iniciando busca de dados no cloud.')
campos = 'id,responsavel(pessoa(cpfCnpj)),comissaoLicitacao(id),atribuicao'
registro_cloud = interacao_cloud.busca_api_fonte_dados(params_exec,
url=url,
campos=campos)
contador = 0
dados = []
for item in registro_cloud:
hash_chaves = model.gerar_hash_chaves(
sistema, tipo_registro, item['comissaoLicitacao']['id'],
item['responsavel']['pessoa']['cpfCnpj'], item['atribuicao'])
registro_encontrado = {
'sistema': sistema,
'tipo_registro': tipo_registro,
'hash_chave_dsk': hash_chaves,
'descricao_tipo_registro': 'Cadastro de Especificação de Material',
'id_gerado': item['id'],
'i_chave_dsk1': item['comissaoLicitacao']['id'],
'i_chave_dsk2': item['responsavel']['pessoa']['cpfCnpj'],
'i_chave_dsk3': item['atribuicao']
}
# print('registro_encontrado', registro_encontrado)
dados.append(registro_encontrado)
contador += 1
print(f'Busca de dados finalizada. Foram encotrados {contador} registros.')
model.insere_tabela_controle_migracao_registro(params_exec,
lista_req=dados)
print(f'Tabelas de controle atualizadas com sucesso.')
def busca_dados_cloud(params_exec, dados_base):
print('- Iniciando busca de dados no cloud.')
url_fonte_dados = 'https://compras.betha.cloud/compras/dados/api/unidadesmedida'
campos = 'id, nome, simbolo'
contador = 0
registros_inseridos = 0
lista_dados = dados_base.to_dict('records')
total_dados = len(lista_dados)
for item in lista_dados:
contador += 1
print(f'\r- Verificando registros: {contador}/{total_dados}',
'\n' if contador == total_dados else '',
end='')
criterio = f'nome = \'{item["descricao"]}\' or simbolo = \'{item["simbolo"]}\''
registro_cloud = interacao_cloud.busca_api_fonte_dados(
params_exec, url=url_fonte_dados, campos=campos, criterio=criterio)
if registro_cloud is not None and len(registro_cloud) > 0:
hash_chaves = model.gerar_hash_chaves(sistema, tipo_registro,
item["cnicodigo"])
registro_encontrado = {
'sistema': sistema,
'tipo_registro': tipo_registro,
'hash_chave_dsk': hash_chaves,
'descricao_tipo_registro': 'Cadastro de Unidades de Medida',
'id_gerado': registro_cloud[0]['id'],
'i_chave_dsk1': item["cnicodigo"]
}
model.insere_tabela_controle_migracao_registro(
params_exec, lista_req=[registro_encontrado])
registros_inseridos += 1
print(
f'- Foram inseridos {registros_inseridos} registros na tabela de controle.'
)
def busca_dados_cloud(params_exec):
print('- Iniciando busca de dados no cloud.')
registros = interacao_cloud.busca_dados_cloud(params_exec, url=url)
print(
f'- Foram encontrados {len(registros)} registros cadastrados no cloud.'
)
registros_formatados = []
try:
for item in registros:
codigotexto = str.replace(item['numeroBanco'], '-', '')
if not re.search("[a-zA-Z]", codigotexto):
codigo = str(int(codigotexto))
hash_chaves = model.gerar_hash_chaves(sistema, tipo_registro,
codigo)
registros_formatados.append({
'sistema': sistema,
'tipo_registro': tipo_registro,
'hash_chave_dsk': hash_chaves,
'descricao_tipo_registro': 'Cadastro de Banco',
'id_gerado': item['id'],
'i_chave_dsk1': codigo
})
model.insere_tabela_controle_migracao_registro(
params_exec, lista_req=registros_formatados)
print(
f'- Busca de {tipo_registro} finalizada. Tabelas de controles atualizas com sucesso.'
)
except Exception as error:
print(f'Erro ao executar função "busca_dados_cloud". {error}')
def busca_dados_cloud(params_exec):
print('- Iniciando busca de dados no cloud.')
registros = interacao_cloud.busca_dados_cloud(params_exec, url=url)
print(f'- Busca de pessoas finalizada, iniciando verificação dos dados obtidos.')
registros_formatados = []
total_contas = 0
try:
for item in registros:
if 'contasBancarias' in item and item['contasBancarias'] is not None:
cpf_pessoa = item['cpf']
for item_conta in item['contasBancarias']:
hash_chaves = model.gerar_hash_chaves(sistema,
tipo_registro,
cpf_pessoa,
item_conta['numero'])
novo_registro = {
'sistema': sistema,
'tipo_registro': tipo_registro,
'hash_chave_dsk': hash_chaves,
'descricao_tipo_registro': 'Cadastro de Contas Bancarias de Pessoas Físicas',
'id_gerado': item_conta['id'],
'i_chave_dsk1': cpf_pessoa,
'i_chave_dsk2': item_conta['numero'],
}
registros_formatados.append(novo_registro)
total_contas += 1
model.insere_tabela_controle_migracao_registro(params_exec, lista_req=registros_formatados)
print(f'- Busca de {tipo_registro} finalizada. Foram executas {total_contas} contas. '
f'Tabelas de controles atualizas com sucesso.')
except Exception as error:
print(f'Erro ao executar função "busca_dados_cloud". {error}')
def iniciar_envio(params_exec, dados, metodo, *args, **kwargs):
print('- Iniciando envio dos dados.')
lista_controle_migracao = []
hoje = datetime.now().strftime("%Y-%m-%d")
token = params_exec['token']
total_dados = len(dados)
contador = 0
total_erros = 0
for item in dados:
lista_dados_enviar = []
lista_controle_migracao = []
contador += 1
print(f'\r- Enviando registros: {contador}/{total_dados}',
'\n' if contador == total_dados else '',
end='')
hash_chaves = model.gerar_hash_chaves(sistema, tipo_registro,
item['clitipoentidade'])
dict_dados = {
'idIntegracao': hash_chaves,
'descricao': item['descricao'],
'tipoAdministracao': {
'valor': item['tipo_administracao']
},
'poder': {
'valor': item['poder']
}
}
# print(f'Dados gerados ({contador}): ', dict_dados)
lista_dados_enviar.append(dict_dados)
lista_controle_migracao.append({
'sistema': sistema,
'tipo_registro': tipo_registro,
'hash_chave_dsk': hash_chaves,
'descricao_tipo_registro': 'Cadastro de Tipos de Administração',
'id_gerado': None,
'json': json.dumps(dict_dados),
'i_chave_dsk1': item['clitipoentidade']
})
if True:
model.insere_tabela_controle_migracao_registro(
params_exec, lista_req=lista_controle_migracao)
req_res = interacao_cloud\
.preparar_requisicao_sem_lote(
lista_dados=lista_dados_enviar,
token=token,
url=url,
tipo_registro=tipo_registro)
model.atualiza_tabelas_controle_envio_sem_lote(
params_exec, req_res, tipo_registro=tipo_registro)
if req_res[0]['mensagem'] is not None:
total_erros += 1
if total_erros > 0:
print(
f'- Envio finalizado. Foram encontrados um total de {total_erros} inconsistência(s) de envio.'
)
else:
print('- Envio de dados finalizado sem inconsistências.')
def iniciar_envio(params_exec, dados, metodo, *args, **kwargs):
print('- Iniciando envio dos dados.')
lista_controle_migracao = []
hoje = datetime.now().strftime("%Y-%m-%d")
token = params_exec['token']
total_dados = len(dados)
contador = 0
total_erros = 0
for item in dados:
lista_dados_enviar = []
lista_controle_migracao = []
contador += 1
print(f'\r- Enviando registros: {contador}/{total_dados}', '\n' if contador == total_dados else '', end='')
hash_chaves = model.gerar_hash_chaves(sistema, tipo_registro, item['clicodigo'], item['ano_processo'],
item['nro_processo'], item['nro_documento'])
url_parametrizada = url.replace('{exercicio}', str(item['ano_processo']))\
.replace('{processoAdministrativoId}', str(item['id_processo']))
dict_dados = {
'idIntegracao': hash_chaves,
'url': url_parametrizada,
'processoAdm': {
'id': item['id_processo']
},
'tipoDocumento': {
'id': item['id_tipo_documento']
}
}
# print(f'Dados gerados ({contador}): ', dict_dados)
lista_dados_enviar.append(dict_dados)
lista_controle_migracao.append({
'sistema': sistema,
'tipo_registro': tipo_registro,
'hash_chave_dsk': hash_chaves,
'descricao_tipo_registro': 'Cadastro de Documentos do Processo',
'id_gerado': None,
'json': json.dumps(dict_dados),
'i_chave_dsk1': item['clicodigo'],
'i_chave_dsk2': item['ano_processo'],
'i_chave_dsk3': item['nro_processo'],
'i_chave_dsk4': item['nro_documento']
})
if True:
model.insere_tabela_controle_migracao_registro(params_exec, lista_req=lista_controle_migracao)
req_res = interacao_cloud\
.preparar_requisicao_sem_lote(
lista_dados=lista_dados_enviar,
token=token,
url=url,
tipo_registro=tipo_registro)
model.atualiza_tabelas_controle_envio_sem_lote(params_exec, req_res, tipo_registro=tipo_registro)
if req_res[0]['mensagem'] is not None:
total_erros += 1
# break
if total_erros > 0:
print(f'- Envio finalizado. Foram encontrados um total de {total_erros} inconsistência(s) de envio.')
else:
print('- Envio de dados finalizado sem inconsistências.')
def iniciar_envio(params_exec, dados, metodo, *args, **kwargs):
print('- Iniciando processo de transformação.')
dh_inicio = datetime.now()
lista_dados_enviar = []
lista_controle_migracao = []
hoje = datetime.now().strftime("%Y-%m-%d")
token = params_exec['token']
total_dados = len(dados)
contador = 0
for item in dados:
contador += 1
# print(f'Gerando JSON: {contador}/{total_dados}', '\n' if contador == total_dados else '', end='')
hash_chaves = model.gerar_hash_chaves(sistema, tipo_registro,
item['id_entidade'],
item['codigo'])
dict_dados = {
'idIntegracao': hash_chaves,
'conteudo': {
'descricao': item['descricao'],
'tipo': item['tipo'],
'categoriaTrabalhador': {
'id': item['categoriatrabalhador']
},
'sefip': item['sefip'],
'geraRais': item['gerarais'],
'vinculoTemporario': item['vinculotemporario'],
'geraCaged': item['geracaged'],
'geraLicencaPremio': item['geralicencapremio'],
'dataFinalObrigatoria': item['datafinalobrigatoria']
}
}
if 'rais' in item and item['rais'] is not None:
dict_dados['conteudo'].update({'rais': item['rais']})
if 'motivorescisao' in item and item['motivorescisao'] is not None:
dict_dados['conteudo'].update(
{'motivoRescisao': {
'id': int(item['motivorescisao'])
}})
print(f'Dados gerados ({contador}): ', dict_dados)
lista_dados_enviar.append(dict_dados)
lista_controle_migracao.append({
'sistema': sistema,
'tipo_registro': tipo_registro,
'hash_chave_dsk': hash_chaves,
'descricao_tipo_registro': 'Cadastro de Vínculo Empregatício',
'id_gerado': None,
'i_chave_dsk1': item['id_entidade'],
'i_chave_dsk2': item['codigo']
})
# print(f'- Processo de transformação finalizado. ({(datetime.now() - dh_inicio).total_seconds()} segundos)')
if True:
model.insere_tabela_controle_migracao_registro(
params_exec, lista_req=lista_controle_migracao)
req_res = interacao_cloud.preparar_requisicao(
lista_dados=lista_dados_enviar,
token=token,
url=url,
tipo_registro=tipo_registro,
tamanho_lote=limite_lote)
model.insere_tabela_controle_lote(req_res)
def iniciar_envio(params_exec, dados, metodo, *args, **kwargs):
print('- Iniciando processo de transformação.')
dh_inicio = datetime.now()
lista_dados_enviar = []
lista_controle_migracao = []
hoje = datetime.now().strftime("%Y-%m-%d")
token = params_exec['token']
total_dados = len(dados)
contador = 0
for item in dados:
contador += 1
# print(f'\r- Gerando JSON: {contador}/{total_dados}', '\n' if contador == total_dados else '', end='')
hash_chaves = model.gerar_hash_chaves(sistema, tipo_registro,
item['chave_dsk1'],
item['chave_dsk2'])
dict_dados = {
'idIntegracao': hash_chaves,
'conteudo': {
'nivel': item['nivel'],
'descricao': item['descricao'],
'numero': item['numero'],
'inicioVigencia': item['inicio_vigencia'],
'configuracao': {
'id': item['configuracao']
}
}
}
print(f'Dados gerados ({contador}): ', dict_dados)
lista_dados_enviar.append(dict_dados)
lista_controle_migracao.append({
'sistema': sistema,
'tipo_registro': tipo_registro,
'hash_chave_dsk': hash_chaves,
'descricao_tipo_registro': 'Cadastro de Lotação Física',
'id_gerado': None,
'i_chave_dsk1': item['chave_dsk1'],
'i_chave_dsk2': item['chave_dsk2']
})
print(
f'- Processo de transformação finalizado. ({(datetime.now() - dh_inicio).total_seconds()} segundos)'
)
if True:
# Insere os registros coletados na tabela de controle
model.insere_tabela_controle_migracao_registro(
params_exec, lista_req=lista_controle_migracao)
# Inicia o procedimento de envio para o cloud
req_res = interacao_cloud.preparar_requisicao(
lista_dados=lista_dados_enviar,
token=token,
url=url,
tipo_registro=tipo_registro,
tamanho_lote=300)
# Insere lote na tabela de controle
model.insere_tabela_controle_lote(req_res)
def iniciar_envio(params_exec, dados, metodo, *args, **kwargs):
print('- Iniciando envio dos dados.')
lista_dados_enviar = []
lista_controle_migracao = []
hoje = datetime.now().strftime("%Y-%m-%d")
token = params_exec['token']
contador = 0
for item in dados:
hash_chaves = model.gerar_hash_chaves(sistema, tipo_registro,
item['numero'], item['banco'])
dict_dados = {
'idIntegracao': hash_chaves,
'conteudo': {
"banco": {
"id": int(item['banco'])
},
"nome": item['nome'],
"numero": item['numero'],
"digito": item['digito']
}
}
if 'bairro' in item and item['bairro'] is not None:
dict_dados['conteudo'].update({'bairro': {'id': item['bairro']}})
if 'logradouro' in item and item['logradouro'] is not None:
dict_dados['conteudo'].update(
{'logradouro': {
'id': item['logradouro']
}})
if 'cep' in item and item['cep'] is not None:
dict_dados['conteudo'].update({'cep': item['cep']})
if 'numeroendereco' in item and item['numeroendereco'] is not None:
dict_dados['conteudo'].update(
{'numeroEndereco': item['numeroendereco']})
contador += 1
# print(f'Dados gerados ({contador}): ', dict_dados)
lista_dados_enviar.append(dict_dados)
lista_controle_migracao.append({
'sistema': sistema,
'tipo_registro': tipo_registro,
'hash_chave_dsk': hash_chaves,
'descricao_tipo_registro': 'Cadastro de Agência Bancária',
'id_gerado': None,
'i_chave_dsk1': item['numero'],
'i_chave_dsk2': item['banco'],
})
if True:
model.insere_tabela_controle_migracao_registro(
params_exec, lista_req=lista_controle_migracao)
req_res = interacao_cloud.preparar_requisicao(
lista_dados=lista_dados_enviar,
token=token,
url=url,
tipo_registro=tipo_registro,
tamanho_lote=limite_lote)
model.insere_tabela_controle_lote(req_res)
print('- Envio de dados finalizado.')
def iniciar_envio(params_exec, dados, metodo, *args, **kwargs):
print('- Iniciando processo de transformação.')
dh_inicio = datetime.now()
lista_dados_enviar = []
lista_controle_migracao = []
hoje = datetime.now().strftime("%Y-%m-%d")
token = params_exec['token']
total_dados = len(dados)
contador = 0
for item in dados:
contador += 1
print(f'\r- Gerando JSON: {contador}/{total_dados}', '\n' if contador == total_dados else '', end='')
hash_chaves = model.gerar_hash_chaves(sistema, tipo_registro, item['entidade'], item['matricula'], item['configuracao'], item['tipoprocessamento'], item['subtipoprocessamento'], item['datainicial'], item['datafinal'])
dict_dados = {
'idIntegracao': hash_chaves,
'conteudo': {
'configuracao': {
'id': item['configuracao']
},
'matricula': {
'id': item['matricula']
},
'tipoProcessamento': item['tipoprocessamento'],
'subTipoProcessamento': item['subtipoprocessamento'],
'dataInicial': item['datainicial'],
'dataFinal': item['datafinal'],
'valor': item['valor'],
'observacao': item['observacao']
}
}
print(f'Dados gerados ({contador}): ', dict_dados)
lista_dados_enviar.append(dict_dados)
lista_controle_migracao.append({
'sistema': sistema,
'tipo_registro': tipo_registro,
'hash_chave_dsk': hash_chaves,
'descricao_tipo_registro': 'Cadastro do Lancamento de Evento',
'id_gerado': None,
'json': json.dumps(dict_dados),
'i_chave_dsk1': item['entidade'],
'i_chave_dsk2': item['matricula'],
'i_chave_dsk3': item['configuracao'],
'i_chave_dsk4': item['tipoprocessamento'],
'i_chave_dsk5': item['subtipoprocessamento'],
'i_chave_dsk6': item['datainicial'],
'i_chave_dsk7': item['datafinal']
})
print(f'- Processo de transformação finalizado. ({(datetime.now() - dh_inicio).total_seconds()} segundos)')
if True:
model.insere_tabela_controle_migracao_registro(params_exec, lista_req=lista_controle_migracao)
req_res = interacao_cloud.preparar_requisicao(lista_dados=lista_dados_enviar,
token=token,
url=url,
tipo_registro=tipo_registro,
tamanho_lote=limite_lote)
model.insere_tabela_controle_lote(req_res)
def iniciar_envio(params_exec, dados, metodo, *args, **kwargs):
print('- Iniciando envio dos dados.')
lista_dados_enviar = []
lista_controle_migracao = []
hoje = datetime.now().strftime("%Y-%m-%d")
token = params_exec['token']
contador = 0
for item in dados:
hash_chaves = model.gerar_hash_chaves(sistema, tipo_registro,
item['descricao'].upper(),
item['municipio'])
dict_dados = {
'idIntegracao': hash_chaves,
'conteudo': {
'descricao':
None if 'descricao' not in item else item['descricao'],
'municipio': {
'id': item['municipio']
},
'tipoLogradouro': {
'id': item['tipologradouro']
},
'cep': item['cep']
}
}
contador += 1
# print(f'Dados gerados ({contador}): ', dict_dados)
lista_dados_enviar.append(dict_dados)
lista_controle_migracao.append({
'sistema':
sistema,
'tipo_registro':
tipo_registro,
'hash_chave_dsk':
hash_chaves,
'descricao_tipo_registro':
'Cadastro de Logradouro',
'id_gerado':
None,
'i_chave_dsk1':
item['descricao'].upper(),
'i_chave_dsk2':
item['municipio']
})
model.insere_tabela_controle_migracao_registro(
params_exec, lista_req=lista_controle_migracao)
req_res = interacao_cloud.preparar_requisicao(
lista_dados=lista_dados_enviar,
token=token,
url=url,
tipo_registro=tipo_registro,
tamanho_lote=limite_lote)
model.insere_tabela_controle_lote(req_res)
print('- Envio de dados finalizado.')
def iniciar_envio(params_exec, dados, metodo, *args, **kwargs):
print('- Iniciando processo de transformação.')
dh_inicio = datetime.now()
lista_dados_enviar = []
lista_controle_migracao = []
hoje = datetime.now().strftime("%Y-%m-%d")
token = params_exec['token']
total_dados = len(dados)
contador = 0
for item in dados:
contador += 1
print(f'\r- Gerando JSON: {contador}/{total_dados}', '\n' if contador == total_dados else '', end='')
hash_chaves = model.gerar_hash_chaves(sistema, tipo_registro, item['numerooficial'], item['tipo'])
dict_dados = {
'idIntegracao': hash_chaves,
'conteudo': {
'numeroOficial': item['numerooficial'],
'tipo': {
'id': item['tipo']
},
'naturezaTextoJuridico': {
'id': item['naturezatextojuridico']
},
'dataCriacao': item['datacriacao'].strftime("%Y-%m-%d")
}
}
if 'ementa' in item and item['ementa'] is not None:
dict_dados['conteudo'].update({'ementa': model.cleanhtml(item['ementa'])})
if 'datavigorar' in item and item['datavigorar'] is not None:
dict_dados['conteudo'].update({'dataVigorar': item['datavigorar'].strftime("%Y-%m-%d")})
if 'datapublicacao' in item and item['datapublicacao'] is not None:
dict_dados['conteudo'].update({'dataPublicacao': item['datapublicacao'].strftime("%Y-%m-%d")})
if 'dataresolucao' in item and item['dataresolucao'] is not None:
dict_dados['conteudo'].update({'dataResolucao': item['dataresolucao'].strftime("%Y-%m-%d")})
# print(f'Dados gerados ({contador}): ', dict_dados)
lista_dados_enviar.append(dict_dados)
lista_controle_migracao.append({
'sistema': sistema,
'tipo_registro': tipo_registro,
'hash_chave_dsk': hash_chaves,
'descricao_tipo_registro': 'Cadastro de Atos',
'id_gerado': None,
'i_chave_dsk1': item['numerooficial'],
'i_chave_dsk2': item['tipo']
})
print(f'- Processo de transformação finalizado. ({(datetime.now() - dh_inicio).total_seconds()} segundos)')
if True:
model.insere_tabela_controle_migracao_registro(params_exec, lista_req=lista_controle_migracao)
req_res = interacao_cloud.preparar_requisicao(lista_dados=lista_dados_enviar,
token=token,
url=url,
tipo_registro=tipo_registro,
tamanho_lote=limite_lote)
model.insere_tabela_controle_lote(req_res)
def iniciar_envio(params_exec, dados, metodo, *args, **kwargs):
print('- Iniciando envio dos dados.')
lista_dados_enviar = []
lista_controle_migracao = []
hoje = datetime.now().strftime("%Y-%m-%d")
token = params_exec['token']
total_dados = len(dados)
contador = 0
for item in dados:
contador += 1
print(f'\r- Gerando JSON: {contador}/{total_dados}',
'\n' if contador == total_dados else '',
end='')
hash_chaves = model.gerar_hash_chaves(sistema, tipo_registro,
item['chave_dsk1'],
item['chave_dsk2'])
url_parametrizada = url.replace('{grupoId}', str(item['id_grupo']))
dict_dados = {
'idIntegracao': hash_chaves,
'url': url_parametrizada,
'descricao': item['nome_classe'],
'especificacao': item['espec_classe'],
'grupo': {
'id': item['id_grupo']
}
}
print(f'Dados gerados ({contador}): ', dict_dados)
lista_dados_enviar.append(dict_dados)
lista_controle_migracao.append({
'sistema': sistema,
'tipo_registro': tipo_registro,
'hash_chave_dsk': hash_chaves,
'descricao_tipo_registro': 'Cadastro de Grupos',
'id_gerado': None,
'json': json.dumps(dict_dados),
'i_chave_dsk1': item['chave_dsk1'],
'i_chave_dsk2': item['chave_dsk2']
})
if True:
model.insere_tabela_controle_migracao_registro(
params_exec, lista_req=lista_controle_migracao)
req_res = interacao_cloud.preparar_requisicao_sem_lote(
lista_dados=lista_dados_enviar,
token=token,
url=url,
tipo_registro=tipo_registro)
model.atualiza_tabelas_controle_envio_sem_lote(
params_exec, req_res, tipo_registro=tipo_registro)
print('- Envio de dados finalizado.')
def iniciar_envio(params_exec, dados, metodo, *args, **kwargs):
print('- Iniciando processo de transformação.')
dh_inicio = datetime.now()
lista_dados_enviar = []
lista_controle_migracao = []
hoje = datetime.now().strftime("%Y-%m-%d")
token = params_exec['token']
total_dados = len(dados)
contador = 0
for item in dados:
contador += 1
print(f'\r- Gerando JSON: {contador}/{total_dados}',
'\n' if contador == total_dados else '',
end='')
hash_chaves = model.gerar_hash_chaves(sistema, tipo_registro,
item['id_entidade'],
item['descricao'],
item['codigoesocial'])
dict_dados = {
'idIntegracao': hash_chaves,
'conteudo': {
'descricao': item['descricao'],
'grupoTrabalhador': item['grupotrabalhador'],
'codigoESocial': item['codigoesocial'],
}
}
# print(f'\nDados gerados ({contador}): ', dict_dados)
lista_dados_enviar.append(dict_dados)
lista_controle_migracao.append({
'sistema': sistema,
'tipo_registro': tipo_registro,
'hash_chave_dsk': hash_chaves,
'descricao_tipo_registro': 'Cadastro de Categorias de Trabalhador',
'id_gerado': None,
'i_chave_dsk1': item['id_entidade'],
'i_chave_dsk2': item['descricao'],
'i_chave_dsk3': item['codigoesocial']
})
print(
f'- Processo de transformação finalizado. ({(datetime.now() - dh_inicio).total_seconds()} segundos)'
)
if True:
model.insere_tabela_controle_migracao_registro(
params_exec, lista_req=lista_controle_migracao)
req_res = interacao_cloud.preparar_requisicao(
lista_dados=lista_dados_enviar,
token=token,
url=url,
tipo_registro=tipo_registro,
tamanho_lote=limite_lote)
model.insere_tabela_controle_lote(req_res)
def iniciar_envio(params_exec, dados, metodo, *args, **kwargs):
print('- Iniciando envio dos dados.')
lista_dados_enviar = []
lista_controle_migracao = []
hoje = datetime.now().strftime("%Y-%m-%d")
token = params_exec['token']
total_dados = len(dados)
contador = 0
for item in dados:
contador += 1
print(f'\r- Gerando JSON: {contador}/{total_dados}',
'\n' if contador == total_dados else '',
end='')
hash_chaves = model.gerar_hash_chaves(sistema, tipo_registro,
item["cnicodigo"])
dict_dados = {
'idIntegracao': hash_chaves,
'simbolo': item['simbolo'],
'nome': item['descricao'],
'nomePlural': item['descricao'],
'fracionaria': item['fracionada'],
'grandeza': {
'valor': item['grandeza'],
'descricao': item['grandeza']
}
}
# print(f'Dados gerados ({contador}): ', dict_dados)
lista_dados_enviar.append(dict_dados)
lista_controle_migracao.append({
'sistema': sistema,
'tipo_registro': tipo_registro,
'hash_chave_dsk': hash_chaves,
'descricao_tipo_registro': 'Cadastro de Unidades de Medida',
'id_gerado': None,
'json': json.dumps(dict_dados),
'i_chave_dsk1': item["cnicodigo"]
})
if True:
model.insere_tabela_controle_migracao_registro(
params_exec, lista_req=lista_controle_migracao)
req_res = interacao_cloud.preparar_requisicao_sem_lote(
lista_dados=lista_dados_enviar,
token=token,
url=url,
tipo_registro=tipo_registro)
model.atualiza_tabelas_controle_envio_sem_lote(
params_exec, req_res, tipo_registro=tipo_registro)
print('- Envio de dados finalizado.')
def iniciar_envio(params_exec, dados, metodo, *args, **kwargs):
print('- Iniciando envio dos dados.')
lista_dados_enviar = []
hoje = datetime.now().strftime("%Y-%m-%d")
token = params_exec['token']
url = "https://contabil-sl.cloud.betha.com.br/contabil/service-layer/v2/api/credores"
for item in dados:
hash_chaves = model.gerar_hash_chaves('1', 'credores', item['chave_1'])
dict_dados = {
'idIntegracao': hash_chaves,
'content': {
'nome': item['nome'],
'tipo': 'FISICA' if item['tipo'] == 'FISICA' else 'JURIDICA',
'dataInclusao': hoje
}
}
if item['tipo'] == 'FISICA':
dict_dados['content'].update({'fisica': {'cpf': item['cpfcnpj']}})
else:
dict_dados['content'].update(
{'juridica': {
'cnpj': item['cpfcnpj']
}})
lista_dados_enviar.append(dict_dados)
# Insere registro atual na tabela 'controle_migracao_registro'
model.insere_tabela_controle_migracao_registro(
params_exec,
req_res={
'sistema': 1,
'tipo_registro': 'credores',
'hash_chave_dsk': hash_chaves,
'descricao_tipo_registro': 'Cadastro de Credores',
'id_gerado': None,
'i_chave_dsk1': item['chave_1'],
'i_chave_dsk2': item['chave_2']
})
req_res = interacao_cloud.preparar_requisicao(
lista_dados=lista_dados_enviar,
token=token,
url=url,
tipo_registro='credores',
tamanho_lote=50)
# Insere lote na tabela 'controle_migracao_lotes'
model.insere_tabela_controle_lote(req_res)
print('- Envio de dados finalizado.')
def busca_dados_cloud(params_exec):
print('- Iniciando busca de dados no cloud.')
campos = 'configuracao(id), id, configuracao.processoAdministrativo.id'
lista_dados = []
if params_exec['clicodigo'] == '2016':
id_entidade = 56 # Prefeitura
elif params_exec['clicodigo'] == '13482':
id_entidade = 2739 # Saúde
elif params_exec['clicodigo'] == '16975':
id_entidade = 2734 # FAMABI
elif params_exec['clicodigo'] == '9769':
id_entidade = 2988 # Institudo
elif params_exec['clicodigo'] == '11968':
id_entidade = 34 # Câmara
criterio = f'configuracao.processoAdministrativo.parametroExercicio.exercicio = {params_exec["ano"]} and entidade.id = {id_entidade}'
registros_cloud = interacao_cloud.busca_api_fonte_dados(params_exec,
url=url,
campos=campos,
criterio=criterio)
if registros_cloud is not None and len(registros_cloud) > 0:
for item in registros_cloud:
hash_chaves = model.gerar_hash_chaves(
sistema, tipo_registro,
item['configuracao']['processoAdministrativo']['id'],
item['id'])
registro_encontrado = {
'sistema':
sistema,
'tipo_registro':
tipo_registro,
'hash_chave_dsk':
hash_chaves,
'descricao_tipo_registro':
'Cadastro de Especificação de Material',
'id_gerado':
item['configuracao']['id'],
'i_chave_dsk1':
item['configuracao']['processoAdministrativo']['id'],
'i_chave_dsk2':
item['id']
}
# print('registro_encontrado', type(registro_encontrado), registro_encontrado)
lista_dados.append(registro_encontrado)
model.insere_tabela_controle_migracao_registro(params_exec,
lista_req=lista_dados)
def busca_dados(params_exec):
print('- Iniciando busca de dados no cloud.')
registros = interacao_cloud.busca_dados_cloud(params_exec, url=url)
print(f'- Foram encontrados {len(registros)} registros cadastrados no cloud.')
registros_formatados = []
for item in registros:
hash_chaves = model.gerar_hash_chaves(sistema, tipo_registro, item['cpf'])
registros_formatados.append({
'sistema': sistema,
'tipo_registro': tipo_registro,
'hash_chave_dsk': hash_chaves,
'descricao_tipo_registro': 'Cadastro de Pessoa Fisica',
'id_gerado': item['id'],
'i_chave_dsk1': item['cpf']
})
model.insere_tabela_controle_migracao_registro(params_exec, lista_req=registros_formatados)
print('- Busca finalizada. Tabelas de controles atualizas com sucesso.')
def iniciar_envio(params_exec, dados, metodo, *args, **kwargs):
print('- Iniciando envio dos dados.')
lista_dados_enviar = []
lista_controle_migracao = []
hoje = datetime.now().strftime("%Y-%m-%d")
token = params_exec['token']
contador = 0
for item in dados:
hash_chaves = model.gerar_hash_chaves(sistema, tipo_registro,
item['id_entidade'],
item['descricao'],
item['classificacao'])
dict_dados = {
'idIntegracao': hash_chaves,
'conteudo': {
"descricao": item['descricao'],
"classificacao": item['classificacao'],
}
}
contador += 1
# print(f'Dados gerados ({contador}): ', dict_dados)
lista_dados_enviar.append(dict_dados)
lista_controle_migracao.append({
'sistema': sistema,
'tipo_registro': tipo_registro,
'hash_chave_dsk': hash_chaves,
'descricao_tipo_registro':
'Cadastro de Tipo de Movimentação Pessoal',
'id_gerado': None,
'i_chave_dsk1': item['id_entidade'],
'i_chave_dsk2': item['descricao'],
'i_chave_dsk3': item['classificacao']
})
if True:
model.insere_tabela_controle_migracao_registro(
params_exec, lista_req=lista_controle_migracao)
req_res = interacao_cloud.preparar_requisicao(
lista_dados=lista_dados_enviar,
token=token,
url=url,
tipo_registro=tipo_registro,
tamanho_lote=limite_lote)
model.insere_tabela_controle_lote(req_res)
print('- Envio de dados finalizado.')
def busca_dados_cloud(params_exec, dados_base):
print('- Iniciando busca de dados no cloud.')
url_fonte_dados = 'https://compras.betha.cloud/compras/dados/api/despesas'
campos = 'entidade(id), parametroExercicio(exercicio), recursoContabil(numero), organograma, funcao, subFuncao, ' \
'programa, acao, natureza'
contador = 0
registros_inseridos = 0
lista_dados = dados_base.to_dict('records')
total_dados = len(lista_dados)
for item in lista_dados:
contador += 1
print(f'\r- Verificando registros: {contador}/{total_dados}',
'\n' if contador == total_dados else '',
end='')
criterio = f'entidade.id = {item["id_entidade"]} and parametroExercicio.exercicio = {item["loaano"]} and ' \
f'organograma = \'{item["organograma"]}\' and funcao = {item["funcao"]} and subFuncao = ' \
f'{item["subfuncao"]} and programa = {item["programa"]} and acao = \'{item["acao"]}\' and ' \
f'natureza = \'{item["natureza"]}\' and recursoContabil.numero = \'{item["recurso_bth"]}\''
# print('criterio', criterio)
registro_cloud = interacao_cloud.busca_api_fonte_dados(
params_exec, url=url_fonte_dados, campos=campos, criterio=criterio)
if registro_cloud is not None and len(registro_cloud) > 0:
hash_chaves = model.gerar_hash_chaves(sistema, tipo_registro,
item["id_entidade"],
item['loaano'],
item['dotcodigo'])
registro_encontrado = {
'sistema': sistema,
'tipo_registro': tipo_registro,
'hash_chave_dsk': hash_chaves,
'descricao_tipo_registro': 'Cadastro de Despesas',
'id_gerado': registro_cloud[0]['id'],
'i_chave_dsk1': item['id_entidade'],
'i_chave_dsk2': item['loaano'],
'i_chave_dsk3': item['dotcodigo']
}
model.insere_tabela_controle_migracao_registro(
params_exec, lista_req=[registro_encontrado])
registros_inseridos += 1
print(
f'- Foram inseridos {registros_inseridos} registros na tabela de controle.'
)
def busca_dados(params_exec):
print('- Iniciando busca de dados no cloud.')
registros = interacao_cloud.busca_dados_cloud(params_exec, url=url)
print(
f'- Foram encontrados {len(registros)} registros cadastrados no cloud.'
)
registros_formatados = []
for item in registros:
hash_chaves = model.gerar_hash_chaves(sistema, tipo_registro, '56',
item['matricula']['id'],
item['tipoProcessamento'],
item['subTipoProcessamento'],
item['competencia'],
item['dataPagamento'])
registros_formatados.append({
'sistema':
sistema,
'tipo_registro':
tipo_registro,
'hash_chave_dsk':
hash_chaves,
'descricao_tipo_registro':
'Cadastro de Bairro',
'id_gerado':
item['id'],
'i_chave_dsk1':
'56',
'i_chave_dsk2':
item['matricula']['id'],
'i_chave_dsk3':
item['tipoProcessamento'],
'i_chave_dsk4':
item['subTipoProcessamento'],
'i_chave_dsk5':
item['competencia'],
'i_chave_dsk6':
item['dataPagamento']
})
model.insere_tabela_controle_migracao_registro(
params_exec, lista_req=registros_formatados)
print('- Busca finalizada. Tabelas de controles atualizas com sucesso.')
def busca_dados_cloud(params_exec):
print('- Iniciando busca de dados no cloud.')
registros = interacao_cloud.busca_dados_cloud(params_exec, url=url)
print(f'- Foram encontrados {len(registros)} registros cadastrados no cloud.')
registros_formatados = []
try:
id_entidade = interacao_cloud.get_dados_token(params_exec.get('token'))['entityId']
for item in registros:
hash_chaves = model.gerar_hash_chaves(sistema, tipo_registro, id_entidade, item['descricao'])
registro = {
'sistema': sistema,
'tipo_registro': tipo_registro,
'hash_chave_dsk': hash_chaves,
'descricao_tipo_registro': 'Cadastro de Motivos de Alteração Salarial',
'id_gerado': item['id'],
'i_chave_dsk1': id_entidade,
'i_chave_dsk2': item['descricao']
}
registros_formatados.append(registro)
model.insere_tabela_controle_migracao_registro(params_exec, lista_req=registros_formatados)
print(f'- Busca de {tipo_registro} finalizada. Tabelas de controles atualizas com sucesso.')
except Exception as error:
print(f'Erro ao executar função "busca_dados_cloud". {error}')
def busca_dados_cloud(params_exec, dados_base):
print('- Iniciando busca de dados no cloud.')
campos = 'id, material.id'
contador = 1
lista_dados = dados_base.to_dict('records')
total_dados = len(lista_dados)
for item in lista_dados:
print(f'\r- Enviando registros: {contador}/{total_dados}', '\n' if contador == total_dados else '', end='')
criterio = f'material.id = {item["id_material"]}'
registro_cloud = interacao_cloud.busca_api_fonte_dados(params_exec, url=url, campos=campos, criterio=criterio)
if registro_cloud is not None:
hash_chaves = model.gerar_hash_chaves(sistema, tipo_registro, item["codigo_produto"])
registro_encontrado = {
'sistema': sistema,
'tipo_registro': tipo_registro,
'hash_chave_dsk': hash_chaves,
'descricao_tipo_registro': 'Cadastro de Especificação de Material',
'id_gerado': registro_cloud[0]['id'],
'i_chave_dsk1': item["codigo_produto"]
}
model.insere_tabela_controle_migracao_registro(params_exec, lista_req=[registro_encontrado])
contador += 1
def iniciar_envio(params_exec, dados, metodo, *args, **kwargs):
print('- Iniciando envio dos dados.')
lista_controle_migracao = []
hoje = datetime.now().strftime("%Y-%m-%d")
token = params_exec['token']
total_dados = len(dados)
contador = 0
total_erros = 0
for item in dados:
lista_dados_enviar = []
lista_controle_migracao = []
contador += 1
print(f'\r- Enviando registros: {contador}/{total_dados}',
'\n' if contador == total_dados else '',
end='')
hash_chaves = model.gerar_hash_chaves(
sistema, tipo_registro, item['clicodigo'], item['ano_processo'],
item['nro_processo'], item['separador'], item['nro_lote'],
item['separador'], item['numero_item_original'])
url_parametrizada = url.replace('{exercicio}', str(item['ano_processo']))\
.replace('{processoAdministrativoId}', str(item['id_processo']))
dict_dados = {
'idIntegracao': hash_chaves,
'url': url_parametrizada,
'processoAdministrativo': {
'id': item['id_processo']
},
'configuracaoItem': {
'processoAdministrativo': {
'id': item['id_processo']
},
'materialEspecificacao': {
'id': item['id_material_especificacao']
},
'valorUnitario': item['valor_unitario'],
'valorTotal': item['valor_total'],
'quantidadeTotal': item['quantidade'],
'tipoBeneficio': {
'valor': item['tipo_beneficio']
},
'amostra': item['amostra']
},
'numero': item['numero_item'],
'quantidade': item['quantidade'],
'valorUnitario': item['valor_unitario'],
'valorTotal': item['valor_total'],
'percentual': item['percentual'],
'tipoParticipacao': {
'valor': item['tipo_participacao']
},
'material': {
'id': item['id_material']
},
'materialEspecificacao': {
'id': item['id_material_especificacao']
},
'amostra': item['amostra']
}
if item['possui_duplicado'] is True:
dict_dados['materialEspecificacao']['id'] = int(
item['id_material_duplicado_epec'])
dict_dados['configuracaoItem']['materialEspecificacao'][
'id'] = int(item['id_material_duplicado_epec'])
# print(f'Dados gerados ({contador}): ', json.dumps(dict_dados))
lista_dados_enviar.append(dict_dados)
lista_controle_migracao.append({
'sistema':
sistema,
'tipo_registro':
tipo_registro,
'hash_chave_dsk':
hash_chaves,
'descricao_tipo_registro':
'Cadastro de Item Livre do Processo',
'id_gerado':
None,
'json':
json.dumps(dict_dados),
'i_chave_dsk1':
item['clicodigo'],
'i_chave_dsk2':
item['ano_processo'],
'i_chave_dsk3':
item['nro_processo'],
'i_chave_dsk4':
item['separador'],
'i_chave_dsk5':
item['nro_lote'],
'i_chave_dsk6':
item['separador'],
'i_chave_dsk7':
item['numero_item_original']
})
if True:
model.insere_tabela_controle_migracao_registro(
params_exec, lista_req=lista_controle_migracao)
req_res = interacao_cloud\
.preparar_requisicao_sem_lote(
lista_dados=lista_dados_enviar,
token=token,
url=url,
tipo_registro=tipo_registro)
model.atualiza_tabelas_controle_envio_sem_lote(
params_exec, req_res, tipo_registro=tipo_registro)
if req_res[0]['mensagem'] is not None:
total_erros += 1
# break
if total_erros > 0:
print(
f'- Envio finalizado. Foram encontrados um total de {total_erros} inconsistência(s) de envio.'
)
else:
print('- Envio de dados finalizado sem inconsistências.')
def iniciar_envio(params_exec, dados, metodo, *args, **kwargs):
print('- Iniciando envio dos dados.')
lista_controle_migracao = []
hoje = datetime.now().strftime("%Y-%m-%d")
token = params_exec['token']
total_dados = len(dados)
contador = 0
total_erros = 0
for item in dados:
lista_dados_enviar = []
lista_controle_migracao = []
contador += 1
print(f'\r- Enviando registros: {contador}/{total_dados}', '\n' if contador == total_dados else '', end='')
hash_chaves = model.gerar_hash_chaves(sistema, tipo_registro, item['clicodigo'],
item['copano'], item['copnro'], item['separador'], item['nfisequencia'],
item['separador'], item['cmiid'])
url_parametrizada = url\
.replace('{exercicio}', str(item['exercicio']))\
.replace('{contratacaoId}', str(item['id_contratacao']))\
.replace('{solicitacaoId}', str(item['id_sf']))\
.replace('{recebimentoId}', str(item['id_recebimento']))
dict_dados = {
'idIntegracao': hash_chaves,
'url': url_parametrizada,
'solicitacaoRecebimento': {
'id': item['id_recebimento']
},
'solicitacaoFornecimentoItem': {
'id': item['id_sf_item']
},
'quantidade': item['itnqtde'],
'desconto': item['desconto'],
'valorTotal': item['itnvalortotal']
}
# print(f'Dados gerados ({contador}): ', json.dumps(dict_dados))
lista_dados_enviar.append(dict_dados)
lista_controle_migracao.append({
'sistema': sistema,
'tipo_registro': tipo_registro,
'hash_chave_dsk': hash_chaves,
'descricao_tipo_registro': 'Cadastro Itens de Recebimento de SF',
'id_gerado': None,
'json': json.dumps(dict_dados),
'i_chave_dsk1': item['clicodigo'],
'i_chave_dsk2': item['copano'],
'i_chave_dsk3': item['copnro'],
'i_chave_dsk4': item['separador'],
'i_chave_dsk5': item['nfisequencia'],
'i_chave_dsk6': item['separador'],
'i_chave_dsk7': item['cmiid'],
})
if True:
model.insere_tabela_controle_migracao_registro(params_exec, lista_req=lista_controle_migracao)
req_res = interacao_cloud\
.preparar_requisicao_sem_lote(
lista_dados=lista_dados_enviar,
token=token,
url=url,
tipo_registro=tipo_registro)
model.atualiza_tabelas_controle_envio_sem_lote(params_exec, req_res, tipo_registro=tipo_registro)
if req_res[0]['mensagem'] is not None:
total_erros += 1
if total_erros > 0:
print(f'- Envio finalizado. Foram encontrados um total de {total_erros} inconsistência(s) de envio.')
else:
print('- Envio de dados finalizado sem inconsistências.')
def iniciar_envio(params_exec, dados, metodo, *args, **kwargs):
print('- Iniciando processo de transformação.')
dh_inicio = datetime.now()
lista_dados_enviar = []
lista_controle_migracao = []
hoje = datetime.now().strftime("%Y-%m-%d")
token = params_exec['token']
total_dados = len(dados)
contador = 0
for item in dados:
contador += 1
print(f'\r- Gerando JSON: {contador}/{total_dados}',
'\n' if contador == total_dados else '',
end='')
hash_chaves = model.gerar_hash_chaves(sistema, tipo_registro,
item['entidade'],
item['matricula'],
item['datainicial'])
dict_dados = {
'idIntegracao': hash_chaves,
'conteudo': {
'situacao': item['situacao'],
'dataInicial': item['datainicial'],
'dataFinal': item['datafinal'],
'configuracaoFerias': {
'id': item['configuracaoferias']
},
'matricula': {
'id': item['matricula']
},
'faltas': item['faltas'],
'diasAdquiridos': item['diasadquiridos'],
'cancelados': item['cancelados'],
'suspensos': item['suspensos'],
'saldo': item['saldo'],
}
}
if 'pagou1tercointegral' in item and item[
'pagou1tercointegral'] is not None:
dict_dados['conteudo'].update(
{'pagou1TercoIntegral': item['pagou1tercointegral']})
if 'diasanuladosrescisao' in item and item[
'diasanuladosrescisao'] is not None:
dict_dados['conteudo'].update(
{'diasAnuladosRescisao': item['diasanuladosrescisao']})
if 'conversao' in item and item['conversao'] is not None:
dict_dados['conteudo'].update({'conversao': item['conversao']})
if 'competenciafechamentoprovisao' in item and item[
'competenciafechamentoprovisao'] is not None:
dict_dados['conteudo'].update({
'competenciaFechamentoProvisao':
item['competenciafechamentoprovisao']
})
if item['movimentacoes'] is not None:
listaconteudo = []
lista = item['movimentacoes'].split('%||%')
if len(lista) > 0:
for listacampo in lista:
campo = listacampo.split('%|%')
for idx, val in enumerate(campo):
if campo[idx] == '':
campo[idx] = None
dict_item_conteudo = {}
if campo[16] is not None:
dict_item_conteudo.update({'conversao': campo[16]})
if False:
if campo[1] is not None:
dict_item_conteudo.update({'dataInicio': campo[1]})
if False:
if campo[2] is not None:
dict_item_conteudo.update({'dataFim': campo[2]})
if campo[3] is not None:
dict_item_conteudo.update({'motivo': campo[3]})
if campo[4] is not None:
dict_item_conteudo.update(
{'dataCancelamento': campo[4]})
if campo[5] is not None:
dict_item_conteudo.update({'dataInicioGozo': campo[5]})
if campo[6] is not None:
dict_item_conteudo.update({'dataFimGozo': campo[6]})
if campo[7] is not None:
dict_item_conteudo.update({'dataPagamento': campo[7]})
if campo[8] is not None:
dict_item_conteudo.update({'diasAbono': campo[8]})
if campo[9] is not None:
dict_item_conteudo.update({'diasGozo': campo[9]})
if campo[10] is not None:
dict_item_conteudo.update({'diasFalta': campo[10]})
if campo[11] is not None:
dict_item_conteudo.update(
{'diasPagosRescisao': campo[11]})
if campo[12] is not None:
dict_item_conteudo.update({'ferias': campo[12]})
if campo[13] is not None:
dict_item_conteudo.update({'tipo': campo[13]})
if campo[14] is not None:
dict_item_conteudo.update({'dataMovimento': campo[14]})
if campo[15] is not None:
dict_item_conteudo.update({'quantidade': campo[15]})
listaconteudo.append(dict_item_conteudo)
if len(listaconteudo) > 0:
dict_dados['conteudo'].update({'movimentacoes': listaconteudo})
print(f'Dados gerados ({contador}): ', dict_dados)
lista_dados_enviar.append(dict_dados)
lista_controle_migracao.append({
'sistema': sistema,
'tipo_registro': tipo_registro,
'hash_chave_dsk': hash_chaves,
'descricao_tipo_registro': 'Cadastro de Lotação Física',
'id_gerado': None,
'json': json.dumps(dict_dados),
'i_chave_dsk1': item['entidade'],
'i_chave_dsk2': item['matricula'],
'i_chave_dsk3': item['datainicial']
})
print(
f'- Processo de transformação finalizado. ({(datetime.now() - dh_inicio).total_seconds()} segundos)'
)
if True:
model.insere_tabela_controle_migracao_registro(
params_exec, lista_req=lista_controle_migracao)
req_res = interacao_cloud.preparar_requisicao(
lista_dados=lista_dados_enviar,
token=token,
url=url,
tipo_registro=tipo_registro,
tamanho_lote=limite_lote)
model.insere_tabela_controle_lote(req_res)
def iniciar_envio(params_exec, dados, metodo, *args, **kwargs):
print('- Iniciando processo de transformação.')
dh_inicio = datetime.now()
lista_dados_enviar = []
lista_controle_migracao = []
hoje = datetime.now().strftime("%Y-%m-%d")
token = params_exec['token']
total_dados = len(dados)
contador = 0
for item in dados:
contador += 1
print(f'\r- Gerando JSON: {contador}/{total_dados}', '\n' if contador == total_dados else '', end='')
hash_chaves = model.gerar_hash_chaves(sistema, tipo_registro, item['entidade'], item['matricula'], item['anoexercicio'])
dict_dados = {
'idIntegracao': hash_chaves,
'conteudo': {
'dataInicial': item['datainicial'],
'dataFinal': item['datafinal'],
'configuracao': item['configuracao'],
'matricula': {
'id': item['matricula']
},
'avosAdquiridos': item['avosadquiridos'],
'avosDireito': item['avosdireito'],
'avosPerdidos': item['avosperdidos'],
'anoExercicio': item['anoexercicio'],
}
}
if 'avosadquiridosfgts' in item and item['avosadquiridosfgts'] is not None:
dict_dados['conteudo'].update({'avosAdquiridosFgts': item['avosadquiridosfgts']})
if 'situacao' in item and item['situacao'] is not None:
dict_dados['conteudo'].update({'situacao': item['situacao']})
if item['movimentacoes'] is not None:
listaconteudo = []
lista = item['movimentacoes'].split('%||%')
if len(lista) > 0:
for listacampo in lista:
campo = listacampo.split('%|%')
for idx, val in enumerate(campo):
if campo[idx] == '':
campo[idx] = None
dict_item_conteudo = {}
if campo[0] is not None:
dict_item_conteudo.update({
'motivo': campo[0]
})
if campo[1] is not None:
dict_item_conteudo.update({
'consideraAvosPerdidos': campo[1]
})
if campo[2] is not None:
dict_item_conteudo.update({
'competencia': campo[2]
})
if campo[3] is not None:
dict_item_conteudo.update({
'valor': campo[3]
})
listaconteudo.append(dict_item_conteudo)
if len(listaconteudo) > 0:
dict_dados['conteudo'].update({
'movimentacoes': listaconteudo
})
print(f'Dados gerados ({contador}): ', dict_dados)
lista_dados_enviar.append(dict_dados)
lista_controle_migracao.append({
'sistema': sistema,
'tipo_registro': tipo_registro,
'hash_chave_dsk': hash_chaves,
'descricao_tipo_registro': 'Cadastro de Lotação Física',
'id_gerado': None,
'json': json.dumps(dict_dados),
'i_chave_dsk1': item['entidade'],
'i_chave_dsk2': item['matricula'],
'i_chave_dsk3': item['anoexercicio']
})
print(f'- Processo de transformação finalizado. ({(datetime.now() - dh_inicio).total_seconds()} segundos)')
if True:
model.insere_tabela_controle_migracao_registro(params_exec, lista_req=lista_controle_migracao)
req_res = interacao_cloud.preparar_requisicao(lista_dados=lista_dados_enviar,
token=token,
url=url,
tipo_registro=tipo_registro,
tamanho_lote=limite_lote)
model.insere_tabela_controle_lote(req_res)
def iniciar_envio(params_exec, dados, metodo, *args, **kwargs):
print('- Iniciando processo de transformação.')
dh_inicio = datetime.now()
lista_dados_enviar = []
lista_controle_migracao = []
hoje = datetime.now().strftime("%Y-%m-%d")
token = params_exec['token']
total_dados = len(dados)
contador = 0
for item in dados:
contador += 1
print(f'\r- Gerando JSON: {contador}/{total_dados}',
'\n' if contador == total_dados else '',
end='')
hash_chaves = model.gerar_hash_chaves(sistema, tipo_registro,
item['id_entidade'],
item['numeroedital'],
item['tiporecrutamento'])
dict_dados = {
'idIntegracao': hash_chaves,
'conteudo': {
'tipoRecrutamento': item['tiporecrutamento'],
'numeroEdital': item['numeroedital'],
'descricao': item['descricao']
}
}
if 'ato' in item and item['ato'] is not None:
dict_dados['conteudo'].update({'ato': {'id': item['ato']}})
if 'percentualpcd' in item and item['percentualpcd'] is not None:
dict_dados['conteudo'].update(
{'percentualPcd': item['percentualpcd']})
if 'datainicialinscricao' in item and item[
'datainicialinscricao'] is not None:
dict_dados['conteudo'].update({
'dataInicialInscricao':
item['datainicialinscricao'].strftime("%Y-%m-%d")
})
if 'datafinalinscricao' in item and item[
'datafinalinscricao'] is not None:
dict_dados['conteudo'].update({
'dataFinalInscricao':
item['datafinalinscricao'].strftime("%Y-%m-%d")
})
if 'dataprorrogacao' in item and item['dataprorrogacao'] is not None:
dict_dados['conteudo'].update({
'dataProrrogacao':
item['dataprorrogacao'].strftime("%Y-%m-%d")
})
if 'datainicialinscricaopcd' in item and item[
'datainicialinscricaopcd'] is not None:
dict_dados['conteudo'].update({
'dataInicialInscricaoPcd':
item['datainicialinscricaopcd'].strftime("%Y-%m-%d")
})
if 'datafinalinscricaopcd' in item and item[
'datafinalinscricaopcd'] is not None:
dict_dados['conteudo'].update({
'dataFinalInscricaoPcd':
item['datafinalinscricaopcd'].strftime("%Y-%m-%d")
})
if 'datahomologacao' in item and item['datahomologacao'] is not None:
dict_dados['conteudo'].update({
'dataHomologacao':
item['datahomologacao'].strftime("%Y-%m-%d")
})
if 'datavalidade' in item and item['datavalidade'] is not None:
dict_dados['conteudo'].update(
{'dataValidade': item['datavalidade'].strftime("%Y-%m-%d")})
if 'dataprorrogacaovalidade' in item and item[
'dataprorrogacaovalidade'] is not None:
dict_dados['conteudo'].update({
'dataProrrogacaoValidade':
item['dataprorrogacaovalidade'].strftime("%Y-%m-%d")
})
if 'dataencerramento' in item and item['dataencerramento'] is not None:
dict_dados['conteudo'].update({
'dataEncerramento':
item['dataencerramento'].strftime("%Y-%m-%d")
})
# print(f'\nDados gerados ({contador}): ', dict_dados)
lista_dados_enviar.append(dict_dados)
lista_controle_migracao.append({
'sistema': sistema,
'tipo_registro': tipo_registro,
'hash_chave_dsk': hash_chaves,
'descricao_tipo_registro': 'Cadastro de Concurso',
'id_gerado': None,
'i_chave_dsk1': item['id_entidade'],
'i_chave_dsk2': item['numeroedital'],
'i_chave_dsk3': item['tiporecrutamento']
})
print(
f'- Processo de transformação finalizado. ({(datetime.now() - dh_inicio).total_seconds()} segundos)'
)
if True:
model.insere_tabela_controle_migracao_registro(
params_exec, lista_req=lista_controle_migracao)
req_res = interacao_cloud.preparar_requisicao(
lista_dados=lista_dados_enviar,
token=token,
url=url,
tipo_registro=tipo_registro,
tamanho_lote=limite_lote)
model.insere_tabela_controle_lote(req_res)
