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 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 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 = []
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['ano'])
dict_dados = {
'descricao':
item['descricao'],
'idIntegracao':
hash_chaves,
'mascara':
item['mascara'],
'niveis': [{
'nivel': item['nivel1'],
'descricao': item['descricao1'],
'digitos': item['digito1']
}, {
'nivel': item['nivel2'],
'descricao': item['descricao2'],
'digitos': item['digito2'],
'separador': item['separador']
}, {
'nivel': item['nivel3'],
'descricao': item['descricao3'],
'digitos': item['digito3'],
'separador': item['separador']
}, {
'nivel': item['nivel4'],
'descricao': item['descricao4'],
'digitos': item['digito4'],
'separador': item['separador']
}, {
'nivel': item['nivel5'],
'descricao': item['descricao5'],
'digitos': item['digito5'],
'separador': item['separador']
}]
}
# 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 Configuração de Organogramas',
'id_gerado': None,
'json': json.dumps(dict_dados),
'i_chave_dsk1': item['ano']
})
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.insere_tabela_controle_lote(req_res)
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_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['numero'])
dict_dados = {
'idIntegracao': hash_chaves,
'numero': item['numero'],
'finalidade': item['finalidade'],
'tipoComissao': {
'valor': item['tipo_comissao']
},
'dataExpiracao': item['data_expiracao'],
'tipoAto': {
'id': (id_tipo_ato_padrao
if item['id_tipo_ato'] == 0 else item['id_tipo_ato'])
},
'ato': {
'id':
(id_ato_padrao if item['id_ato'] == 0 else item['id_ato'])
}
}
if len(item['array_membros']) > 0:
lista_membros = []
iterador = 0
encontrou_responsavel = False
for m in item['array_membros']:
iterador += 1
if m['id_responsavel'] is not None and m['atribuicao'] in [
'PRESIDENTE', 'PREGOEIRO', 'LEILOEIRO'
]:
encontrou_responsavel = True
if m['id_responsavel'] is not None:
lista_membros.append({
'responsavel': {
'id': m['id_responsavel']
},
'atribuicao': {
'valor':
'PREGOEIRO'
if iterador == len(item['array_membros'])
and encontrou_responsavel is False else
m['atribuicao']
}
})
dict_dados.update({'membros': lista_membros})
else:
dict_dados.update({
'membros': [{
'responsavel': {
'id': id_responsavel_padrao
},
'atribuicao': {
'valor': 'PREGOEIRO'
}
}]
})
# 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 Comissões de Licitação',
'id_gerado': None,
'json': json.dumps(dict_dados),
'i_chave_dsk1': item['numero']
})
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['ano_sf'], item['nro_sf'])
url_parametrizada = url.replace('{exercicio}', str(item['ano_sf']))\
.replace('{contratacaoId}', str(item['id_contratacao']))
if params_exec['clicodigo'] == '16975':
id_organograma_padrao = 373447
elif params_exec['clicodigo'] == '13482':
id_organograma_padrao = 371827
elif params_exec['clicodigo'] == '2016':
id_organograma_padrao = 392830
dict_dados = {
'idIntegracao': hash_chaves,
'url': url_parametrizada,
'contratacao': {
'id': item['id_contratacao']
},
'organograma': {
'id':
id_organograma_padrao
if item['id_organograma'] == 0 else item['id_organograma']
},
'prazoEntrega': {
'id':
id_prazo_entrega_padrao
if item['id_prazo_entrega'] == 0 else item['id_prazo_entrega']
},
'localEntrega': {
'id':
id_local_entrega_padrao
if item['id_local_entrega'] == 0 else item['id_local_entrega']
},
'fornecedor': {
'id': item['id_fornecedor']
},
'numero': str(item['nro_sf']),
'nomeSolicitante': item['solicitante'],
'data': item['data_sf'],
'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 de SF de Compras Diretas',
'id_gerado': None,
'json': json.dumps(dict_dados),
'i_chave_dsk1': item['clicodigo'],
'i_chave_dsk2': item['ano_sf'],
'i_chave_dsk3': item['nro_sf'],
})
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_minuta'],
item['nro_minuta'])
url_parametrizada = url.replace('{exercicio}', str(item['ano_processo']))\
.replace('{processoAdministrativoId}', str(item['id_processo']))
dict_dados = {
'idIntegracao': hash_chaves,
'url': url_parametrizada,
'processoAdmistrativo': {
'id': item['id_processo']
},
'formaContratacao': {
'valor': item['forma_contratacao']
},
'desclassificaPropostaInvalidaLote': {
'valor': item['desc_prop_invalida_lote']
},
'desclassificaPropostaInvalida': {
'valor': item['desc_prop_invalida']
},
'modalidade': {
'id': item['id_modalidade']
},
'responsavel': {
'id':
id_responsavel_padrao
if item['id_responsavel'] == 0 else item['id_responsavel']
}
}
if item['ano_sequencial'] is not None:
dict_dados.update({'anoSequencial': item['ano_sequencial']})
if item['nro_sequencial'] is not None:
dict_dados.update({'numeroSequencial': item['nro_sequencial']})
# dict_dados.update({'numeroSequencial': int('6' + str(item['nro_sequencial']))})
# dict_dados.update({'numeroSequencial': item['nro_minuta']})
# dict_dados.update({'numeroSequencial': 999})
if item['id_fundamento_legal'] is not None and item[
'id_fundamento_legal'] != 0:
dict_dados.update(
{'fundamentacaoLegal': {
'id': item['id_fundamento_legal']
}})
# dict_dados.update({'fundamentacaoLegal': {'id': 81}}) # Inegibilidade
if item['id_membro_comissao'] is not None and item[
'id_membro_comissao'] != 0:
dict_dados.update(
{'membroComissao': {
'id': item['id_membro_comissao']
}})
# dict_dados.update({'membroComissao': {'id': 53788}}) # Pregoeiro
# dict_dados.update({'membroComissao': {'id': 53417}}) # Presidente
# dict_dados.update({'membroComissao': {'id': 53501}}) # Leiloeiro
if item['registro_preco'] is not None:
dict_dados.update({'registroPreco': item['registro_preco']})
if item['dh_inicio_recebimento_envelopes'] is not None:
dict_dados.update({
'dataInicioRecebimentoEnvelope':
item['dh_inicio_recebimento_envelopes']
})
if item['dh_final_recebimento_envelopes'] is not None:
dict_dados.update({
'dataFinalRecebimentoEnvelope':
item['dh_final_recebimento_envelopes']
})
if item['dh_abertura_envelopes'] is not None:
dict_dados.update(
{'dataAberturaEnvelope': item['dh_abertura_envelopes']})
if item['data_autorizacao_rp'] is not None:
dict_dados.update({
'dataAutorizacaoAdesaoAtaRegPreco':
item['data_autorizacao_rp']
})
# 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 Forma de Contratação do Processo',
'id_gerado': None,
'json': json.dumps(dict_dados),
'i_chave_dsk1': item['clicodigo'],
'i_chave_dsk2': item['ano_minuta'],
'i_chave_dsk3': item['nro_minuta']
})
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['id_entidade'],
item['loaano'],
item['dotcodigo'])
dict_dados = {
'idIntegracao': hash_chaves,
'organograma': item['organograma'],
'funcao': item['funcao'],
'subFuncao': item['subfuncao'],
'programa': item['programa'],
'acao': item['acao'],
'descricao': item['descricao_despesa'],
'naturezaDespesa': item['natureza'],
'mascara': item['mascara'],
'parametrosExerc': {
'id': item['id_exercicio']
},
'recursoContabil': {
'numeroRecurso': item['recurso_bth'],
'descricao': item['desc_recurso']
},
'numeroDespesa': item['dotcodigo']
}
# 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 Despesas',
'id_gerado': None,
'json': json.dumps(dict_dados),
'i_chave_dsk1': item['id_entidade'],
'i_chave_dsk2': item['loaano'],
'i_chave_dsk3': item['dotcodigo']
})
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['chave_dsk1'],
item['chave_dsk2'],
item['chave_dsk3'])
url_parametrizada = url.replace('{exercicio}', str(item['chave_dsk2']))
dict_dados = {
'idIntegracao': hash_chaves,
'url': url_parametrizada,
'entidadeGestora': {
'id': item['id_entidade_gestora']
},
'organograma': {
'id': item['id_organograma']
},
'localEntrega': {
'id': item['id_local_entrega']
},
'parametrosExerc': {
'id': item['id_parametro_exercicio']
},
'codigo': item['codigo'],
'data': item['data_solicitacao'].strftime("%Y-%m-%d"),
'nomeSolicitante': item['nome_solicitante'],
'assunto': model.cleanhtml(item['assunto']),
'tipoNecessidade': {
'valor': item['tipo_necessidade']
},
'objeto': item['objeto'],
'justificativa': model.cleanhtml(item['justificativa']),
'observacao': model.cleanhtml(item['observacao']),
'status': {
'valor': item['status_solicitacao']
},
'situacaoCadastral': {
'valor': item['situacao_cadastral']
},
}
# 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 Solicitações de Compra',
'id_gerado': None,
'json': json.dumps(dict_dados),
'i_chave_dsk1': item['chave_dsk1'],
'i_chave_dsk2': item['chave_dsk2'],
'i_chave_dsk3': item['chave_dsk3']
})
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.')
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_controle_migracao = []
lista_dados_enviar = []
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['clicodigo'],
item['copano'], item['copnro'],
item['separador'],
item['nfisequencia'])
dict_dados = {
'idIntegracao': hash_chaves,
'fornecedor': {
'id': item['id_fornecedor']
},
'tipoComprovante': {
'id': item['id_tipo_comprovante']
},
'numeroComprovante': item['numero_comprovante'],
'dataEmissao': item['data_emissao'],
'valorBruto': item['valor_bruto'],
'valorDesconto': item['valor_desconto'],
'valorLiquido': item['valor_liquido'],
}
if item['serie'] is not None:
dict_dados.update({'serie': item['serie']})
if item['finalidade'] is not None:
dict_dados.update({'finalidade': item['finalidade']})
# 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 Comprovantes',
'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']
})
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 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.')
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_controle_migracao = []
lista_dados_enviar = []
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'])
dict_dados = {
'idIntegracao': hash_chaves,
'codigoMaterial': item['chave_dsk1'],
'descricao': item['descricao'],
'ativo': item['ativo'],
'estocavel': item['estocavel'],
'tipoMaterial': {
'valor': item['tipo_material']
},
'classificacao': {
'valor': item['classificacao']
},
'tipoCombustivel': {
'valor': item['tipocombustivel']
},
'unidadeCompra': {
'id': item['id_un_medida']
},
'unidadeEstoque': {
'id': item['id_un_medida']
},
'classe': {
'id': item['id_classe']
},
'grupo': {
'id': item['id_grupo']
},
'especificacoes': [
{
'descricao': item['especificacao']
}
]
}
if 'datainativacao' in item and item['datainativacao'] is not None:
dict_dados.update({
'dataInativacao': item['datainativacao']
})
# 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 Materiais',
'id_gerado': None,
'json': json.dumps(dict_dados),
'i_chave_dsk1': item['chave_dsk1']
})
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 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)
for reg in dados:
query = f'''select
row_number() over() as id,
'305' as sistema,
'processo-proposta-pendente' as tipo_registro,
*
from (
select distinct
aux.*,
(regexp_replace(u.unicpfcnpj,'[/.-]|[ ]','','g')) as cpf_participante,
0.00 as valor_unitario,
i.cmiqtde as quantidade,
null as marca,
'NAO_COTOU' as situacao,
0 as colocacao,
(select id_gerado from public.controle_migracao_registro where hash_chave_dsk = md5(concat(305, 'processo', aux.clicodigo, aux.minano, aux.minnro))) as id_processo,
(select id_gerado from public.controle_migracao_registro where hash_chave_dsk = md5(concat(305, 'processo-participante', aux.clicodigo, aux.minano, aux.minnro, (regexp_replace(u.unicpfcnpj,'[/.-]|[ ]','','g'))))) as id_participante,
(select id_gerado from public.controle_migracao_registro where hash_chave_dsk = md5(concat(305, 'processo-item', aux.clicodigo, aux.minano, aux.minnro, '@', coalesce(i.lotcodigo, 0) , '@', i.cmiitem))) as id_item,
(select id_gerado from public.controle_migracao_registro where hash_chave_dsk = md5(concat(305, 'processo-proposta-pendente', aux.clicodigo, aux.minano, aux.minnro, (regexp_replace(u.unicpfcnpj,'[/.-]|[ ]','','g')), aux.cmiid))) as id_gerado
from (
select
participante.clicodigo,
participante.minano,
participante.minnro,
item.cmiid ,
participante.unicodigo
from (
select pl.clicodigo, pl.minano, pl.minnro, pl.unicodigo
from wco.tbparlic pl
where pl.clicodigo = {reg['clicodigo']}
and pl.minano = {reg['minano']}
and pl.minnro = {reg['minnro']}
) participante
cross join (
select it.clicodigo, it.minano, it.minnro, it.cmiid
from wco.tbitemin it
where it.clicodigo = {reg['clicodigo']}
and it.minano = {reg['minano']}
and it.minnro = {reg['minnro']}
) item
) aux
left join wco.tbitemin i on (i.clicodigo = aux.clicodigo and i.minano = aux.minano and i.minnro = aux.minnro and i.cmiid = aux.cmiid)
inner join wun.tbunico u on (u.unicodigo = aux.unicodigo)
where not exists (
select 1
from wco.tbcadqcp qcp
where qcp.clicodigo = aux.clicodigo
and qcp.minano = aux.minano
and qcp.minnro = aux.minnro
and qcp.unicodigo = aux.unicodigo
and qcp.cmiid = aux.cmiid
)
and exists (
select 1
from wco.tbcadqcp qcp
where qcp.clicodigo = aux.clicodigo
and qcp.minano = aux.minano
and qcp.minnro = aux.minnro
)
) tab
where id_gerado is null
and id_processo is not null
and id_participante is not null
and id_item is not null
order by 1, 2 desc, 3 desc, 4 asc'''
pgcnn = model.PostgreSQLConnection()
df = pgcnn.exec_sql(query, index_col='id')
lista_dados = [i for i in df.to_dict('records')]
total_erros = 0
contador = 0
total_dados = len(lista_dados)
if total_dados > 0:
print(
f'- Enviando propostas pendentes do processo {reg["minnro"]}/{reg["minano"]} ({reg["clicodigo"]})'
)
for item in lista_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['minano'],
item['minnro'], item['cpf_participante'], item['cmiid'])
url_parametrizada = url.replace('{exercicio}', str(item['minano'])) \
.replace('{processoAdministrativoId}', str(item['id_processo']))
dict_dados = {
'idIntegracao': hash_chaves,
'url': url_parametrizada,
'processoAdministrativo': {
'id': item['id_processo']
},
'participante': {
'id': item['id_participante']
},
'item': {
'id': item['id_item']
},
'situacao': {
'valor': item['situacao']
},
'quantidade': item['quantidade'],
'valorUnitarioPercentual': item['valor_unitario']
}
if item['marca'] is not None:
dict_dados.update({'marca': item['marca']})
# 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 Propostas Pendentes do Processo',
'id_gerado':
None,
'json':
json.dumps(dict_dados),
'i_chave_dsk1':
item['clicodigo'],
'i_chave_dsk2':
item['minano'],
'i_chave_dsk3':
item['minnro'],
'i_chave_dsk4':
item['cpf_participante'],
'i_chave_dsk5':
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_dados > 0:
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['chave_dsk1'], item['chave_dsk2'],
item['chave_dsk3'], item['chave_dsk4'], item['chave_dsk5'])
url_parametrizada = url.replace('{exercicio}', str(item['chave_dsk2']))\
.replace('{solicitacaoId}', str(item['id_solicitacao']))
dict_dados = {
'idIntegracao': hash_chaves,
'url': url_parametrizada,
'solicitacao': {
'id': item['id_solicitacao']
},
'material': {
'id': item['id_material']
},
"materialEspecificacao": {
'id': item['id_especificacao']
},
'numero': item['numero'],
'quantidade': item['quantidade'],
'valorUnitario': item['valor_unitario'],
'valorTotal': item['valor_total'],
'status': {
'valor': item['status']
},
'amostra': item['amostra']
}
# 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 Item da Solicitações de Compra',
'id_gerado': None,
'json': json.dumps(dict_dados),
'i_chave_dsk1': item['chave_dsk1'],
'i_chave_dsk2': item['chave_dsk2'],
'i_chave_dsk3': item['chave_dsk3'],
'i_chave_dsk4': item['chave_dsk4'],
'i_chave_dsk5': item['chave_dsk5']
})
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['cpf_cnpj'])
dict_dados = {
'idIntegracao': hash_chaves,
'cpfCnpj': item['cpf_cnpj'],
'dataInclusao': item['datainclusao'],
'nome': item['nome'],
'tipo': {
'valor': item['tipo_pessoa']
},
'situacao': {
'valor': item['situacao']
}
}
if item['tipo_pessoa'] == 'JURIDICA':
if item['nome_fantasia'] is not None:
dict_dados.update({'nomeFantasia': item['nome_fantasia']})
"""if item['inscricao_estadual'] is not None and item['estadoInscricao'] is not None:
dict_dados.update({'inscricaoEstadual': item['inscricao_estadual']})
dict_dados.update({'estadoInscricao': {'id': item['estadoInscricao']}})"""
if len(item['array_emails']) > 0:
dict_dados.update(
{'email': {
'descricao': item['array_emails'][0]
}})
if len(item['array_telefones']) > 0:
dict_dados.update(
{'telefone': {
'descricao': item['array_telefones'][0]
}})
if len(item['array_enderecos']) > 0:
# print(type(item['array_enderecos']), item['array_enderecos'])
if item['array_enderecos'][0]['bairro'] is not None \
and item['array_enderecos'][0]['logradouro'] \
and item['array_enderecos'][0]['municipio']:
dict_dados.update({
'endereco': {
'bairro': {
'id': item['array_enderecos'][0]['id_bairro']
},
'municipio': {
'id': item['array_enderecos'][0]['id_municipio']
},
'logradouro': {
'id': item['array_enderecos'][0]['id_logradouro']
},
'cep': item['array_enderecos'][0]['cep'],
'complemento':
item['array_enderecos'][0]['complemento'],
'numero': item['array_enderecos'][0]['numero']
}
})
# 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 Responsáveis',
'id_gerado': None,
'json': json.dumps(dict_dados),
'i_chave_dsk1': item['cpf_cnpj'],
})
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_minuta'],
item['nro_minuta'])
url_parametrizada = url.replace('{exercicio}',
str(item['ano_processo']))
dict_dados = {
'idIntegracao': hash_chaves,
'url': url_parametrizada,
'parametroExerc': {
'id': item['id_parametro_exercicio']
},
'localEntrega': {
'id': (id_local_entrega_padrao if item['id_local_entrega'] == 0
else item['id_local_entrega'])
},
'tipoObjeto': {
'id': item['id_tipo_objeto']
},
'formaJulgamento': {
'id': item['id_forma_julgamento']
},
'prazoEntrega': {
'id': (id_prazo_entrega_padrao if item['id_prazo_entrega'] == 0
else item['id_prazo_entrega'])
},
'formaPagamento': {
'id': item['id_forma_pagamento']
},
'dataProcesso': item['data_processo'],
'numeroProcesso': item['nro_processo'],
'numeroProtocolo': item['numero_protocolo'],
'anoProtocolo': item['ano_protocolo'],
'controleSaldo': {
'valor': item['controle_saldo']
},
'previsaoSubcontratacao': item['previsao_subcontratacao'],
'objeto': item['objeto'],
'destinatarioEducacao': item['destinatario_educacao'],
'destinatarioSaude': item['destinatario_saude']
}
if item['observacao'] is not None:
dict_dados.update({'observacao': item['observacao']})
if item['justificativa'] is not None:
dict_dados.update({'justificativa': item['justificativa']})
if item['id_regime_execucao'] != 0:
dict_dados.update(
{'regimeExecucao': {
'id': item['id_regime_execucao']
}})
# 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 Processos Administrativos',
'id_gerado': None,
'json': json.dumps(dict_dados),
'i_chave_dsk1': item['clicodigo'],
'i_chave_dsk2': item['ano_minuta'],
'i_chave_dsk3': item['nro_minuta']
})
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['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 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['nro_ato'], item['ano_ato'],
item['tipo_ato'])
dict_dados = {
'idIntegracao': hash_chaves,
'tiposAto': {
'id': item['id_tipo_ato']
},
'naturezaTextoJuridico': {
'id': item['id_natureza_texto_juridico']
},
'numero': item['numero_oficial'],
'dataCriacao': item['data_criacao'].strftime("%Y-%m-%d"),
'dataRevogacao': None,
'dataSancao': None,
'numeroDiarioOficial': None
}
if item['data_publicacao'] is not None:
dict_dados.update({
'dataPublicacao':
item['data_publicacao'].strftime("%Y-%m-%d")
})
if item['data_vigorar'] is not None:
dict_dados.update(
{'dataVigorar': item['data_vigorar'].strftime("%Y-%m-%d")})
if item['ementa'] is not None:
dict_dados.update({'ementa': model.cleanhtml(item['ementa'])})
# 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,
'json': json.dumps(dict_dados),
'i_chave_dsk1': item['nro_ato'],
'i_chave_dsk2': item['ano_ato'],
'i_chave_dsk3': item['tipo_ato']
})
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['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['ano_ata'], item['nro_ata'],
item['separador'],
item['arpsequencia'])
url_parametrizada = url.replace('{exercicio}', str(item['ano_ata']))
dict_dados = {
'idIntegracao': hash_chaves,
'url': url_parametrizada,
'sequencial': item['sequencial'],
'entidade': {
'id': item['id_entidade']
},
'tipoInstrumento': {
'id': item['id_tipo_instrumento']
},
'tipoObjeto': {
'id': item['id_tipo_objeto']
},
'processoAdministrativo': {
'entidade': {
'id': item['id_entidade']
},
'numero': item['nro_processo'],
'ano': item['ano_processo']
},
'fundamentacaoLegal': {
'id': item['id_fundamentacao_legal']
},
'ataRegistroPrecoContrato': {
'id': item['id_ata']
},
'numeroTermo': item['nro_ata'],
'ano': item['ano_ata'],
'objetoContratacao': item['objeto'],
'tipoControleSaldo': {
'valor': item['tipo_controle_saldo']
},
'fornecedor': {
'id': item['id_fornecedor']
},
'dataAssinatura': item['dt_assinatura'],
'dataInicioVigencia': item['dt_inicio_vigencia'],
'dataFimVigencia': item['dt_fim_vigencia'],
'origem': {
'valor': item['origem']
},
'observacao': item['observacao'],
"situacao": {
"valor": item['situacao']
}
}
if item['valor_original'] != 0.0:
dict_dados.update({'valorOriginal': item['valor_original']})
# 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 Contratações ARP',
'id_gerado': None,
'json': json.dumps(dict_dados),
'i_chave_dsk1': item['clicodigo'],
'i_chave_dsk2': item['ano_ata'],
'i_chave_dsk3': item['nro_ata'],
'i_chave_dsk4': item['separador'],
'i_chave_dsk5': item['arpsequencia']
})
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.')
