def mudar_status_boleto(p_titulo_id, p_situacao, p_protocolo):
u = update(contas_receber).where(contas_receber.c.id == p_titulo_id)
u = u.values(protocolo_baixa_cobranca=p_protocolo,
situacao_cobranca="Baixa: " + p_situacao)
result = conn.execute(u)
if result.rowcount > 0:
print(str(result.rowcount)) # Número de linhas afetadas pelo update
else:
print("Erro atualizando dados do boleto")
def gravar_situacao_boleto(p_id_integracao):
u = update(contas_receber).where(contas_receber.c.codigo_externo == p_id_integracao)
u = u.values(
situacao_cobranca = None,
protocolo_baixa_cobranca = None,
codigo_externo = None
)
result = conn.execute(u)
if result.rowcount > 0:
print(str(result.rowcount)) # Número de linhas afetadas pelo update
else:
print("Erro atualizando situação do boleto")
def limpar_dados_titulo(p_titulo_id):
u = update(contas_receber).where(contas_receber.c.id == p_titulo_id)
u = u.values(
protocolo_geracao_pdf = None,
situacao_cobranca = None,
codigo_externo = None
)
result = conn.execute(u)
if result.rowcount > 0:
print(str(result.rowcount)) # Número de linhas afetadas pelo update
else:
print("Erro atualizando dados do boleto")
def criar_evento_ok(row):
l_novo_evento = json.loads(row)
# Final do processamento do evento
u = update(eventos).where(eventos.c.id == l_evento_id)
u = u.values(status="Finalizado", historico="Convênio criado com sucesso")
result = conn.execute(u)
if result.rowcount > 0:
print(str(result.rowcount)) # Número de linhas afetadas pelo update
else:
print("Erro atualizando status do evento")
def criar_evento_ok(row):
l_novo_evento = json.loads(row)
# Final do processamento do evento
u = update(eventos).where(eventos.c.id == l_evento_id)
u = u.values(status="Finalizado", historico="Conta criada com sucesso")
result = conn.execute(u)
if result.rowcount > 0:
print(str(result.rowcount)) # Número de linhas afetadas pelo update
else:
print("Erro atualizando status do evento")
# Evento para o próximo microservice
novo_evento = eventos.insert().values(
username="******",
tipo=l_novo_evento.get("tipo"),
evento="NovoConvenio",
historico="Criar convênio bancário",
empresa_id=l_novo_evento.get("empresa_id"),
status="Pendente",
)
result = conn.execute(novo_evento)
def criar_evento_processando(json_data):
for key, value in json_data.items():
if key == "empresa_id":
global l_empresa_id
l_empresa_id = value
if key == "id":
global l_evento_id
l_evento_id = value
u = update(eventos).where(eventos.c.id == l_evento_id)
u = u.values(status="Processando",
historico="Processando criação de nova conta")
result = conn.execute(u)
if result.rowcount > 0:
print(str(
result.rowcount)) # Número de linhas afetadas pelo update
else:
print("Erro atualizando status do evento")
def consultar_boletos():
s = (
contas_receber.select()
.with_only_columns(
[
contas_receber.c.id,
contas_receber.c.empresa_id,
contas_receber.c.cliente_id,
contas_receber.c.conta_financeira_id,
contas_receber.c.convenio_bancario_id,
contas_receber.c.documento,
contas_receber.c.data_emissao,
contas_receber.c.data_vencimento,
contas_receber.c.valor,
contas_receber.c.codigo_externo,
]
)
.where(contas_receber.c.codigo_externo != None )
.where(contas_receber.c.codigo_externo != 'Emitir_Cobranca')
.where(contas_receber.c.situacao_cobranca == None)
)
results = conn.execute(s)
# Necessário armazenar o retorno para outros usos.
rv = results.fetchall()
# use special handler for dates and decimals
results_json = json.dumps([dict(r) for r in rv], default=alchemyencoder)
results_qtd = len(rv)
if results_qtd > 0:
json_data = json.loads(results_json)
return json_data
else:
return None
def criar_webhook(p_cnpj):
# api_token = "5f67cfd82864d50690961714d9dbaa23"
api_token = config('API_TOKEN')
url = "http://homologacao.plugboleto.com.br/api/v1/webhooks"
myHeaders = {
"Content-Type": "application/json",
"cnpj-sh": "00115150000140",
"token-sh": api_token,
"cnpj-cedente": p_cnpj,
"Accept": "application/json",
}
myBody = {
"ativo": True,
"url": "http://dev.hos.com.br:8080/ords/hos/financas/boletos/",
"eventos": {
"registrou": False,
"liquidou": True,
"baixou": True,
"alterou": False,
"rejeitou": False
},
"headers": {
"cnpj_cedente": p_cnpj
}
}
response = requests.post(url, json=myBody, headers=myHeaders)
if response.status_code == 200:
dados_webhook = json.loads(response.text)
nova_notificacao = notificacoes.insert().values(
titulo="Processo Concluído",
texto="Webhook cadastrado com sucesso.",
tipo="tecnospeed",
status="Sucesso",
empresa_id=l_empresa_id,
)
result = conn.execute(nova_notificacao)
else:
dados_webhook = json.loads(response.text)
l_titulo_erro = dados_webhook.get("_mensagem")
for erro in dados_webhook["_dados"]:
nova_notificacao = notificacoes.insert().values(
titulo=l_titulo_erro,
texto=erro["_campo"] + ": " + erro["_erro"],
tipo="tecnospeed",
status="Erro",
empresa_id=l_empresa_id,
evento_id=l_evento_id,
)
result = conn.execute(nova_notificacao)
def criar_novo_cedente(row):
# Buscar registro para obter a api
# api_token = "5f67cfd82864d50690961714d9dbaa23"
# Buscar como variável de ambiente
api_token = config('API_TOKEN')
api_encoded = base64.b64encode(api_token.encode("utf-8"))
api_key = str(api_encoded, "utf-8")
t_razao_social = ""
t_fantasia = ""
t_cnpj = ""
t_endereco = ""
t_numero = ""
t_complemento = ""
t_bairro = ""
t_cep = ""
t_codigo_ibge = ""
t_telefone = ""
t_email = ""
p_empresa_id = row.get("empresa_id")
sql = text("select e.razao_social, e.nome_fantasia, e.cnpj, "
"e.endereco, e.numero, e.complemento, "
"e.bairro, e.cep, c.codigo_ibge, "
"e.telefone, e.email "
"from empresas e, cidades c "
"where e.id = :empresa_id "
"and c.id = e.cidade_id ")
result = conn.execute(sql, empresa_id=p_empresa_id)
rec = result.fetchall()
# print(rec)
for row in rec:
t_razao_social = row[0]
t_fantasia = row[1]
t_cnpj = row[2]
t_endereco = row[3]
t_numero = row[4]
t_complemento = row[5]
t_bairro = row[6]
t_cep = row[7]
t_codigo_ibge = row[8]
t_telefone = row[9]
t_email = row[10]
url = "http://homologacao.plugboleto.com.br/api/v1/cedentes"
myHeaders = {
"Content-Type": "application/json",
"cnpj-sh": "00115150000140",
"token-sh": api_token,
"Accept": "application/json",
}
myBody = {
"CedenteRazaoSocial": t_razao_social,
"CedenteNomeFantasia": t_fantasia,
"CedenteCPFCNPJ": t_cnpj,
"CedenteEnderecoLogradouro": t_endereco,
"CedenteEnderecoNumero": t_numero,
"CedenteEnderecoComplemento": t_complemento,
"CedenteEnderecoBairro": t_bairro,
"CedenteEnderecoCEP": t_cep,
"CedenteEnderecoCidadeIBGE": t_codigo_ibge,
"CedenteTelefone": t_telefone,
"CedenteEmail": t_email,
}
# print(myBody)
response = requests.post(url, json=myBody, headers=myHeaders)
if response.status_code == 200:
print(response.status_code)
print(response.text)
dados = json.loads(response.text)
print(dados)
nova_notificacao = notificacoes.insert().values(
titulo="Processo Concluído",
texto="Cedente cadastrado com sucesso.",
tipo="tecnospeed",
status="Sucesso",
empresa_id=l_empresa_id,
)
result = conn.execute(nova_notificacao)
criar_webhook(t_cnpj)
criar_eventos_notificacoes(t_cnpj)
return dados
else:
print("Erro:" + str(response.status_code))
print(response.text)
dados = json.loads(response.text)
# -->> Tratar mensagem de erro
# inserir em notificações
l_titulo_erro = dados.get("_mensagem")
for erro in dados["_dados"]:
nova_notificacao = notificacoes.insert().values(
titulo=l_titulo_erro,
texto=erro["_campo"] + ": " + erro["_erro"],
tipo="tecnospeed",
status="Erro",
empresa_id=l_empresa_id,
evento_id=l_evento_id,
)
result = conn.execute(nova_notificacao)
return None
def preparar_dados(row):
# Buscar api como variável de ambiente
api_token = config('API_TOKEN')
api_encoded = base64.b64encode(api_token.encode("utf-8"))
api_key = str(api_encoded, "utf-8")
t_cnpj = ""
p_empresa_id = row.get("empresa_id")
p_titulo_id = row.get("id")
sql_empresa = text("select cnpj "
"from empresas "
"where id = :empresa_id ")
result = conn.execute(sql_empresa, empresa_id=p_empresa_id)
rec = result.fetchone()
t_cnpj = rec.cnpj
sql_conta = text(
"select cc.numero_conta, cc.digito_conta, cb.numero as numero_convenio, b.numero as numero_banco, "
"c.email, c.numero as cliente_numero, c.bairro, c.cep, c.endereco, c.nome as nome_cliente, c.telefone, "
"c.cnpj, cid.cidade as nome_cidade, est.uf, to_char(cr.data_emissao, 'DD/MM/YYYY') as data_emissao, "
"to_char(cr.data_vencimento, 'DD/MM/YYYY') as data_vencimento, "
"cr.documento, to_char(cr.valor, '999G999G999G999G990D00') as valor, cr.id, cr.codigo_externo, "
"cr.mensagem_01, cr.mensagem_02, cr.mensagem_03, cr.mensagem_local_pagamento "
"from contas_financeiras cc, convenios_bancarios cb, "
"bancos b, clientes c, contas_receber cr, "
"cidades cid, estados est "
"where cc.id = cr.conta_financeira_id "
"and b.id = cc.banco_id "
"and cb.id = cr.convenio_bancario_id "
"and c.id = cr.cliente_id "
"and cid.id = c.cidade_id "
"and est.id = c.estado_id "
"and cr.id = :titulo_id ")
result = conn.execute(sql_conta, titulo_id=p_titulo_id)
rec = result.fetchall()
for row in rec:
t_id = row.id
t_conta_numero = row.numero_conta
t_digito_conta = row.digito_conta
t_convenio_numero = row.numero_convenio
t_numero_banco = row.numero_banco
t_email = row.email
t_endereco_numero = row.cliente_numero
t_bairro = row.bairro
t_cep = row.cep
t_cidade = row.nome_cidade
t_estado = row.uf
t_logradouro = row.endereco
t_pais = 'Brasil'
t_cliente_nome = row.nome_cliente
t_cliente_cnpj = row.cnpj
t_telefone = row.telefone
t_data_emissao = row.data_emissao
t_data_vencimento = row.data_vencimento
t_documento = row.documento
t_valor = row.valor
t_mensagem_01 = row.mensagem_01
t_mensagem_02 = row.mensagem_02
t_mensagem_03 = row.mensagem_03
t_mensagem_local = row.mensagem_local_pagamento
url = "https://homologacao.plugboleto.com.br/api/v1/boletos/lote"
myHeaders = {
"Content-Type": "application/json",
"cnpj-sh": "00115150000140",
"token-sh": api_token,
"cnpj-cedente": t_cnpj,
"Accept": "application/json",
}
myBody = [{
"CedenteContaNumero": t_conta_numero,
"CedenteContaNumeroDV": t_digito_conta,
"CedenteConvenioNumero": t_convenio_numero,
"CedenteContaCodigoBanco": t_numero_banco,
"SacadoCPFCNPJ": t_cliente_cnpj,
"SacadoEmail": t_email,
"SacadoEnderecoNumero": t_endereco_numero,
"SacadoEnderecoBairro": t_bairro,
"SacadoEnderecoCEP": t_cep,
"SacadoEnderecoCidade": t_cidade,
"SacadoEnderecoComplemento": "",
"SacadoEnderecoLogradouro": t_logradouro,
"SacadoEnderecoPais": "Brasil",
"SacadoEnderecoUF": t_estado,
"SacadoNome": t_cliente_nome,
"SacadoTelefone": t_telefone,
"SacadoCelular": t_telefone,
"TituloDataEmissao": t_data_emissao,
"TituloDataVencimento": t_data_vencimento,
"TituloMensagem01": t_mensagem_01,
"TituloMensagem02": t_mensagem_02,
"TituloMensagem03": t_mensagem_03,
"TituloNossoNumero": t_documento,
"TituloNumeroDocumento": t_documento,
"TituloValor": t_valor,
"TituloLocalPagamento": t_mensagem_local
}]
# print(myBody)
# print("------------------")
response = requests.post(url, json=myBody, headers=myHeaders)
if response.status_code == 200:
# print(response.status_code)
# print(response.text)
dados = json.loads(response.text)
# print(dados)
for retorno in dados["_dados"]["_sucesso"]:
id_retorno = retorno["idintegracao"]
print("Id Integração: " + id_retorno)
# salvar o id retornado no titulo
gravar_codigo_externo_boleto(id_retorno, p_titulo_id)
else:
print("Erro:" + str(response.status_code))
# print(response.text)
dados = json.loads(response.text)
# -->> Tratar mensagem de erro
# inserir em notificações
l_titulo_erro = 'Erro gerando cobrança'
for erro in dados["_dados"]["_falha"]:
nova_notificacao = notificacoes.insert().values(
titulo=l_titulo_erro,
texto=erro["_erro"]["erros"]["boleto"],
tipo="tecnospeed",
status="Erro",
empresa_id=p_empresa_id,
)
result = conn.execute(nova_notificacao)
def preparar_dados(row):
# Buscar api como variável de ambiente
api_token = config('API_TOKEN')
api_encoded = base64.b64encode(api_token.encode("utf-8"))
api_key = str(api_encoded, "utf-8")
t_cnpj = ""
p_empresa_id = row.get("empresa_id")
p_titulo_id = row.get("id")
p_codigo_externo = row.get("codigo_externo")
sql_empresa = text("select cnpj "
"from empresas "
"where id = :empresa_id "
)
result = conn.execute(sql_empresa, empresa_id=p_empresa_id)
rec = result.fetchone()
t_cnpj = rec.cnpj
url = "https://homologacao.plugboleto.com.br/api/v1/boletos?IdIntegracao=" + p_codigo_externo
myHeaders = {
"Content-Type": "application/json",
"cnpj-sh": "00115150000140",
"token-sh": api_token,
"cnpj-cedente": t_cnpj,
"Accept": "application/json",
}
myBody = None
response = requests.get(url, json=myBody, headers=myHeaders)
if response.status_code == 200:
# print(response.status_code)
# print(response.text)
dados = json.loads(response.text)
# print(dados)
for retorno in dados["_dados"]:
l_situacao = retorno["situacao"]
# salvar a situacao do boleto
gravar_situacao_boleto(p_titulo_id, l_situacao)
else:
print("Erro:" + str(response.status_code))
print(response.text)
dados = json.loads(response.text)
# -->> Tratar mensagem de erro
# inserir em notificações
l_titulo_erro = 'Erro consultando cobrança'
nova_notificacao = notificacoes.insert().values(
titulo=l_titulo_erro,
texto="Registro não encontrado",
tipo="tecnospeed",
status="Erro",
empresa_id=p_empresa_id,
)
result = conn.execute(nova_notificacao)
def preparar_dados(row):
# Buscar api como variável de ambiente
api_token = config('API_TOKEN')
api_encoded = base64.b64encode(api_token.encode("utf-8"))
api_key = str(api_encoded, "utf-8")
t_cnpj = ""
p_empresa_id = row.get("empresa_id")
p_titulo_id = row.get("id")
p_codigo_externo = row.get("codigo_externo")
p_situacao_cobranca = row.get("situacao_cobranca")
if p_situacao_cobranca.lower() in [
"emitido", "registrado", "liquidado", "baixado"
]:
sql_empresa = text("select cnpj "
"from empresas "
"where id = :empresa_id ")
result = conn.execute(sql_empresa, empresa_id=p_empresa_id)
rec = result.fetchone()
t_cnpj = rec.cnpj
url = "https://homologacao.plugboleto.com.br/api/v1/boletos/impressao/lote"
myHeaders = {
"Content-Type": "application/json",
"cnpj-sh": "00115150000140",
"token-sh": api_token,
"cnpj-cedente": t_cnpj,
"Accept": "application/json",
}
myBody = {"TipoImpressao": "0", "Boletos": [p_codigo_externo]}
response = requests.post(url, json=myBody, headers=myHeaders)
if response.status_code == 200:
# print(response.status_code)
# print(response.text)
dados = json.loads(response.text)
# print(dados)
l_protocolo = dados["_dados"]["protocolo"]
# salvar o protocolo de geração do PDF
gravar_protocolo_pdf(p_titulo_id, l_protocolo)
else:
# print("Erro:" + str(response.status_code))
# print(response.text)
dados = json.loads(response.text)
# -->> Tratar mensagem de erro, inserir em notificações
nova_notificacao = notificacoes.insert().values(
titulo="Erro solicitando PDF do boleto",
texto="Códigos externos não encontrados",
tipo="tecnospeed",
status="Erro",
empresa_id=p_empresa_id,
)
result = conn.execute(nova_notificacao)
def preparar_dados(row):
# Buscar api como variável de ambiente
api_token = config('API_TOKEN')
api_encoded = base64.b64encode(api_token.encode("utf-8"))
api_key = str(api_encoded, "utf-8")
t_cnpj = ""
p_empresa_id = row.get("empresa_id")
p_titulo_id = row.get("id")
p_codigo_externo = row.get("codigo_externo")
sql_empresa = text("select cnpj "
"from empresas "
"where id = :empresa_id "
)
result = conn.execute(sql_empresa, empresa_id=p_empresa_id)
rec = result.fetchone()
t_cnpj = rec.cnpj
url = "https://homologacao.plugboleto.com.br/api/v1/boletos/descarta/lote"
myHeaders = {
"Content-Type": "application/json",
"cnpj-sh": "00115150000140",
"token-sh": api_token,
"cnpj-cedente": t_cnpj,
"Accept": "application/json",
}
myBody = [ p_codigo_externo ]
response = requests.post(url, json=myBody, headers=myHeaders)
if response.status_code == 200:
# print(response.status_code)
# print(response.text)
# limpar os dados de integração do titulo no sistema
limpar_dados_titulo(p_titulo_id)
else:
# print("Erro:" + str(response.status_code))
# print(response.text)
dados = json.loads(response.text)
# -->> Tratar mensagem de erro, inserir em notificações
for erro in dados["_dados"]["_falha"]:
nova_notificacao = notificacoes.insert().values(
titulo="Erro descartando boleto",
texto=erro["_erro"],
tipo="tecnospeed",
status="Erro",
empresa_id=p_empresa_id,
)
result = conn.execute(nova_notificacao)
def criar_novo_convenio(row):
# Buscar registro para obter a api
# api_token = "5f67cfd82864d50690961714d9dbaa23"
api_token = config('API_TOKEN')
api_encoded = base64.b64encode(api_token.encode("utf-8"))
api_key = str(api_encoded, "utf-8")
t_cnpj = ""
p_empresa_id = row.get("empresa_id")
sql_empresa = text("select cnpj "
"from empresas "
"where id = :empresa_id "
)
result = conn.execute(sql_empresa, empresa_id=p_empresa_id)
rec = result.fetchone()
# print(rec.cnpj)
t_cnpj = rec.cnpj
sql_conta = text(
"select cc.codigo_externo, c.id, c.conta_financeira_id, c.nome, c.numero, "
"c.carteira, c.especie, c.padrao_cnab, c.reiniciar_numero_remessa, "
"c.registro_instantaneo, c.api_id, c.api_key, "
"c.api_secret, c.codigo_estacao "
"from convenios_bancarios c, contas_fin_integracoes cc "
"where c.conta_financeira_id = cc.conta_financeira_id "
)
result = conn.execute(sql_conta)
rec = result.fetchall()
for row in rec:
t_id = row.id
t_numero_convenio = row.numero
t_descricao = row.nome
t_carteira = row.carteira
t_especie = row.especie
t_padrao_cnab = row.padrao_cnab
t_reiniciar_diariamente = row.reiniciar_numero_remessa
t_conta = row.codigo_externo
t_api_id = row.api_id
t_api_key = row.api_key
t_api_secret = row.api_secret
t_codigo_estacao = row.codigo_estacao
global l_convenio_id
l_convenio_id = t_id
url = "https://homologacao.plugboleto.com.br/api/v1/cedentes/contas/convenios"
myHeaders = {
"Content-Type": "application/json",
"cnpj-sh": "00115150000140",
"token-sh": api_token,
"cnpj-cedente": t_cnpj,
"Accept": "application/json",
}
myBody = {
"ConvenioNumero": t_numero_convenio,
"ConvenioDescricao": t_descricao,
"ConvenioCarteira": t_carteira,
"ConvenioEspecie": t_especie,
"ConvenioPadraoCNAB": t_padrao_cnab,
"ConvenioNumeroRemessa": "1",
"ConvenioDensidadeRemessa": "1600",
"ConvenioRegistroInstantaneo": True,
"ConvenioApiId": t_api_id,
"ConvenioApiKey": t_api_key,
"ConvenioApiSecret": t_api_secret,
"ConvenioEstacao": t_codigo_estacao,
"ConvenioNossoNumeroBanco": False,
"ConvenioReiniciarDiariamente": True,
"Conta": t_conta
}
# print(myBody)
# print("------------------")
response = requests.post(url, json=myBody, headers=myHeaders)
if response.status_code == 200:
print(response.status_code)
print(response.text)
dados = json.loads(response.text)
print(dados)
nova_notificacao = notificacoes.insert().values(
titulo="Processo Concluído",
texto="Convênio cadastrado com sucesso.",
tipo="tecnospeed",
status="Sucesso",
empresa_id=l_empresa_id,
)
result = conn.execute(nova_notificacao)
gravar_codigo_externo_convenio(dados)
else:
print("Erro:" + str(response.status_code))
print(response.text)
dados = json.loads(response.text)
# -->> Tratar mensagem de erro
# inserir em notificações
l_titulo_erro = dados.get("_mensagem")
for erro in dados["_dados"]:
nova_notificacao = notificacoes.insert().values(
titulo=l_titulo_erro,
texto=erro["_campo"] + ": " + erro["_erro"],
tipo="tecnospeed",
status="Erro",
empresa_id=l_empresa_id,
evento_id=l_evento_id,
)
result = conn.execute(nova_notificacao)
def criar_nova_conta(row):
# Buscar registro para obter a api
# api_token = "5f67cfd82864d50690961714d9dbaa23"
api_token = config('API_TOKEN')
api_encoded = base64.b64encode(api_token.encode("utf-8"))
api_key = str(api_encoded, "utf-8")
t_cnpj = ""
p_empresa_id = row.get("empresa_id")
sql_empresa = text("select cnpj "
"from empresas "
"where id = :empresa_id ")
result = conn.execute(sql_empresa, empresa_id=p_empresa_id)
rec = result.fetchone()
# print(rec.cnpj)
t_cnpj = rec.cnpj
sql_conta = text(
"select b.numero, c.id, c.agencia, c.digito_agencia, c.numero_conta, "
"c.digito_conta, c.codigo_beneficiario, c.codigo_empresa "
"from contas_financeiras c, bancos b "
"where c.empresa_id = :empresa_id "
"and c.usar_para_cobranca = 'Sim' "
"and c.banco_id = b.id")
result = conn.execute(sql_conta, empresa_id=p_empresa_id)
rec = result.fetchall()
for row in rec:
t_id = row.id
t_numero_banco = row.numero
t_agencia = row.agencia
t_digito_agencia = row.digito_agencia
t_numero_conta = row.numero_conta
t_digito_conta = row.digito_conta
t_codigo_beneficiario = row.codigo_beneficiario
t_codigo_empresa = row.codigo_empresa
global l_conta_financeira_id
l_conta_financeira_id = t_id
url = "http://homologacao.plugboleto.com.br/api/v1/cedentes/contas"
myHeaders = {
"Content-Type": "application/json",
"cnpj-sh": "00115150000140",
"token-sh": api_token,
"cnpj-cedente": t_cnpj,
"Accept": "application/json",
}
myBody = {
"ContaCodigoBanco": t_numero_banco,
"ContaAgencia": t_agencia,
"ContaAgenciaDV": t_digito_agencia,
"ContaNumero": t_numero_conta,
"ContaNumeroDV": t_digito_conta,
"ContaTipo": "CORRENTE",
"ContaCodigoBeneficiario": t_codigo_beneficiario,
"ContaCodigoEmpresa": t_codigo_empresa,
"ContaValidacaoAtiva": True,
"ContaImpressaoAtualizada": True,
}
print(myBody)
print("------------------")
response = requests.post(url, json=myBody, headers=myHeaders)
if response.status_code == 200:
print(response.status_code)
print(response.text)
dados = json.loads(response.text)
print(dados)
nova_notificacao = notificacoes.insert().values(
titulo="Processo Concluído",
texto="Conta cadastrado com sucesso.",
tipo="tecnospeed",
status="Sucesso",
empresa_id=l_empresa_id,
)
result = conn.execute(nova_notificacao)
gravar_codigo_externo_conta(dados)
# return dados
else:
print("Erro:" + str(response.status_code))
print(response.text)
dados = json.loads(response.text)
# -->> Tratar mensagem de erro
# inserir em notificações
l_titulo_erro = dados.get("_mensagem")
for erro in dados["_dados"]:
nova_notificacao = notificacoes.insert().values(
titulo=l_titulo_erro,
texto=erro["_campo"] + ": " + erro["_erro"],
tipo="tecnospeed",
status="Erro",
empresa_id=l_empresa_id,
evento_id=l_evento_id,
)
result = conn.execute(nova_notificacao)