- Aprovações (apr_*) passam a gravar a data/hora real do OK, lida do history do Holmes - Rota de notas busca o history antes de gravar e roda o banco fora do event loop - Cliente do Holmes (app/utils/holmes.py) e contador de chamadas (api_tracker.py) para SQL Server - Configuração sai do .env e vai para config.json (modelo em config.example.json) Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
205 lines
8.2 KiB
Python
205 lines
8.2 KiB
Python
import json
|
|
from datetime import date, datetime, timedelta, timezone
|
|
from decimal import ROUND_HALF_UP, Decimal
|
|
|
|
from sqlalchemy.pool import PoolProxiedConnection
|
|
|
|
from app.v1.modules.escrituracao.models.modelo_notas import NotasHolmesInput
|
|
|
|
FUSO_BRASILIA = timezone(timedelta(hours=-3))
|
|
ORDEM_ETAPAS = ('gerente', 'adm_loja', 'controladoria', 'contas_pagar')
|
|
|
|
|
|
class NotasDespesas:
|
|
def __init__(self, conexao: PoolProxiedConnection) -> None:
|
|
self.conexao = conexao
|
|
|
|
@staticmethod
|
|
def montar_vencimentos(valor: Decimal, datas: list[date]) -> list[dict]:
|
|
# Divide em centavos pra soma bater exato; a sobra vai pra primeira parcela
|
|
total_centavos = int(valor * 100)
|
|
qtd = len(datas)
|
|
base, sobra = divmod(total_centavos, qtd)
|
|
|
|
parcelas = []
|
|
for i, data in enumerate(datas):
|
|
centavos = base + (sobra if i == 0 else 0)
|
|
parcelas.append({
|
|
'valor': float(Decimal(centavos) / 100),
|
|
'data': data.isoformat(),
|
|
})
|
|
return parcelas
|
|
|
|
@staticmethod
|
|
def traduzir_aprovacao(aprovacao: str | None) -> str | None:
|
|
# Troca "🟢 Aprovado" / "🟡 Pendente" por Feito / Não Feito (o varchar não guarda emoji)
|
|
if not aprovacao:
|
|
return aprovacao
|
|
linhas = []
|
|
for linha in aprovacao.splitlines():
|
|
if '—' in linha:
|
|
etapa, status = linha.rsplit('—', 1)
|
|
linha = f"{etapa.strip()} — {'Feito' if 'aprovado' in status.lower() else 'Não Feito'}"
|
|
linhas.append(linha)
|
|
return '\n'.join(linhas)
|
|
|
|
@staticmethod
|
|
def extrair_aprovacoes(situacao: str | None) -> dict[str, str | None]:
|
|
# Separa cada etapa na sua coluna. O gerente varia (GER TI, GER PEÇAS, GER USADOS...),
|
|
# por isso ele é testado por último, depois das etapas fixas
|
|
aprovacoes: dict[str, str | None] = {'gerente': None, 'adm_loja': None, 'controladoria': None, 'contas_pagar': None}
|
|
if not situacao:
|
|
return aprovacoes
|
|
for linha in situacao.splitlines():
|
|
if '—' not in linha:
|
|
continue
|
|
etapa, status = (parte.strip() for parte in linha.rsplit('—', 1))
|
|
etapa = etapa.upper()
|
|
if 'ADM' in etapa: # ADM LOJA, ADM MATRIZ...
|
|
aprovacoes['adm_loja'] = status
|
|
elif 'CONTROLADOR' in etapa:
|
|
aprovacoes['controladoria'] = status
|
|
elif 'CONTAS PAGAR' in etapa:
|
|
aprovacoes['contas_pagar'] = status
|
|
elif 'GER' in etapa:
|
|
aprovacoes['gerente'] = status
|
|
return aprovacoes
|
|
|
|
@staticmethod
|
|
def datas_aprovacao(historico: dict | None) -> list[datetime]:
|
|
# Horários dos "Aprovar" do history, do mais antigo pro mais novo.
|
|
# Se o processo foi reprovado/devolvido, as aprovações anteriores não valem mais: recomeça a contagem
|
|
if not historico:
|
|
return []
|
|
eventos = sorted(
|
|
(h for h in historico.get('histories', []) if h.get('key') == 'history.take_action'),
|
|
key=lambda h: h['created_at'],
|
|
)
|
|
datas = []
|
|
for evento in eventos:
|
|
acao = (evento.get('properties') or {}).get('action_name', '').lower()
|
|
if acao.startswith('aprov'):
|
|
momento = datetime.fromisoformat(evento['created_at'].replace('Z', '+00:00'))
|
|
# Sem fuso no final: a coluna datetime do SQL Server não guarda fuso
|
|
datas.append(momento.astimezone(FUSO_BRASILIA).replace(tzinfo=None, microsecond=0))
|
|
elif any(p in acao for p in ('reprov', 'devolv', 'recus', 'rejeit', 'retorn')):
|
|
datas = []
|
|
return datas
|
|
|
|
@classmethod
|
|
def montar_aprovacoes(cls, apr: dict[str, str | None], historico: dict | None) -> list:
|
|
# O 1º OK do history vai pra 1ª etapa do fluxo, o 2º pra 2ª...
|
|
# Devolve (aprovado, data) por etapa, na ordem das colunas apr_*; a data pode vir None
|
|
# quando o history não trouxe a hora, e aí o SQL decide o que gravar
|
|
datas = dict(zip([e for e in ORDEM_ETAPAS if apr[e] is not None], cls.datas_aprovacao(historico)))
|
|
parametros = []
|
|
for etapa in ORDEM_ETAPAS:
|
|
aprovado = apr[etapa] == 'Feito'
|
|
parametros += [1 if aprovado else 0, datas.get(etapa) if aprovado else None]
|
|
return parametros
|
|
|
|
def inserir_nota_despesas(self, nota: NotasHolmesInput, historico: dict | None = None) -> str:
|
|
props = nota.properties
|
|
|
|
datas = sorted(
|
|
d for d in (getattr(props, f'vencimento_{n}' if n > 1 else 'vencimento') for n in range(1, 13))
|
|
if d is not None
|
|
)
|
|
if not datas and props.data_vencimento:
|
|
datas = [props.data_vencimento]
|
|
if not datas:
|
|
raise ValueError('Nota sem data de vencimento')
|
|
if props.valor is None:
|
|
raise ValueError('Nota sem valor')
|
|
|
|
valor = Decimal(str(props.valor)).quantize(Decimal('0.01'), rounding=ROUND_HALF_UP)
|
|
vencimentos_json = json.dumps(self.montar_vencimentos(valor, datas))
|
|
situacao = self.traduzir_aprovacao(props.aprovacao)
|
|
apr = self.montar_aprovacoes(self.extrair_aprovacoes(situacao), historico)
|
|
cursor = self.conexao.cursor()
|
|
|
|
# A mesma nota pode chegar mais de uma vez: se já existe, atualiza.
|
|
# Aprovações: pendente = NULL; aprovada = hora do history; sem hora no history,
|
|
# mantém a que já estava gravada ou, se não tinha, usa a hora atual
|
|
cursor.execute("""
|
|
UPDATE PD_HOLMES_APOLLO
|
|
SET
|
|
EMPRESA_NOME = ?,
|
|
TIPO_DOCUMENTO = ?,
|
|
SITUACAO = ?,
|
|
NUM_NOTA = ?,
|
|
DTA_EMISSAO = ?,
|
|
VALOR_NOTA = ?,
|
|
VENCIMENTOS_JSON = ?,
|
|
ORIGEM = ?,
|
|
cpfcnpj = ?,
|
|
observacao = ?,
|
|
apr_gerente = CASE WHEN ? = 1 THEN COALESCE(CAST(? AS datetime), apr_gerente, GETDATE()) END,
|
|
apr_adm_loja = CASE WHEN ? = 1 THEN COALESCE(CAST(? AS datetime), apr_adm_loja, GETDATE()) END,
|
|
apr_controladoria = CASE WHEN ? = 1 THEN COALESCE(CAST(? AS datetime), apr_controladoria, GETDATE()) END,
|
|
apr_contas_pagar = CASE WHEN ? = 1 THEN COALESCE(CAST(? AS datetime), apr_contas_pagar, GETDATE()) END
|
|
WHERE ID_HOLMES = ?
|
|
""", (
|
|
props.empresa,
|
|
props.tipo_de_documento,
|
|
situacao,
|
|
props.num_nota,
|
|
props.data_emissao,
|
|
valor,
|
|
vencimentos_json,
|
|
props.origem,
|
|
props.cpf_cnpj,
|
|
props.observacao,
|
|
*apr,
|
|
nota.id,
|
|
))
|
|
|
|
if cursor.rowcount > 0:
|
|
self.conexao.commit()
|
|
return 'atualizada'
|
|
|
|
cursor.execute("""
|
|
INSERT INTO PD_HOLMES_APOLLO (
|
|
ID_HOLMES,
|
|
PROTOCOLO,
|
|
FLUXO,
|
|
EMPRESA_NOME,
|
|
TIPO_DOCUMENTO,
|
|
cpfcnpj,
|
|
SITUACAO,
|
|
NUM_NOTA,
|
|
DTA_EMISSAO,
|
|
VALOR_NOTA,
|
|
VENCIMENTOS_JSON,
|
|
ORIGEM,
|
|
observacao,
|
|
apr_gerente,
|
|
apr_adm_loja,
|
|
apr_controladoria,
|
|
apr_contas_pagar
|
|
) VALUES (
|
|
?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?,
|
|
CASE WHEN ? = 1 THEN COALESCE(CAST(? AS datetime), GETDATE()) END,
|
|
CASE WHEN ? = 1 THEN COALESCE(CAST(? AS datetime), GETDATE()) END,
|
|
CASE WHEN ? = 1 THEN COALESCE(CAST(? AS datetime), GETDATE()) END,
|
|
CASE WHEN ? = 1 THEN COALESCE(CAST(? AS datetime), GETDATE()) END
|
|
)
|
|
""", (
|
|
nota.id,
|
|
props.protocolo,
|
|
props.nome_fluxo,
|
|
props.empresa,
|
|
props.tipo_de_documento,
|
|
props.cpf_cnpj,
|
|
situacao,
|
|
props.num_nota,
|
|
props.data_emissao,
|
|
valor,
|
|
vencimentos_json,
|
|
props.origem,
|
|
props.observacao,
|
|
*apr,
|
|
))
|
|
|
|
self.conexao.commit()
|
|
return 'inserida'
|