Datas de aprovação pelo history do Holmes e config em JSON

- 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>
This commit is contained in:
Ricardo 2026-10-08 14:05:29 -03:00
parent 3f46186719
commit 8986e3ce03
10 changed files with 798 additions and 66 deletions

View file

@ -1,13 +0,0 @@
# Copie estas variáveis para o .env e preencha os valores
# SQL Server
DB_HOST=
DB_PORTA=1433
DB_DATABASE=
DB_LOGIN=
DB_SENHA=
# Opcionais (já têm valor padrão)
# DB_DRIVER=ODBC Driver 17 for SQL Server
# DB_POOL_SIZE=5
# DB_POOL_MAX_OVERFLOW=10

1
.gitignore vendored
View file

@ -4,3 +4,4 @@ __pycache__/
*.pyc *.pyc
*.pyo *.pyo
*.log *.log
config.json

View file

@ -1,34 +1,32 @@
from pathlib import Path from pathlib import Path
from pydantic import SecretStr from pydantic import BaseModel, SecretStr
from pydantic_settings import BaseSettings, SettingsConfigDict
# Raiz do projeto (api-podium/), pra achar o .env independente de onde a API for iniciada
RAIZ_PROJETO = Path(__file__).resolve().parents[2]
class Settings(BaseSettings): class BancoConfig(BaseModel):
model_config = SettingsConfigDict(
env_file=RAIZ_PROJETO / '.env',
env_file_encoding='utf-8',
env_ignore_empty=True, # variável vazia no .env conta como não configurada
extra='ignore', # outras variáveis no .env não geram erro
)
# SQL Server
db_host: str db_host: str
db_porta: int = 1433 db_porta: int = 1433
db_database: str db_database: str
db_login: str db_login: str
db_senha: SecretStr # SecretStr evita que a senha apareça em print/log db_senha: SecretStr
db_driver: str = 'ODBC Driver 17 for SQL Server' db_driver: str = 'ODBC Driver 17 for SQL Server'
# Pool de conexões
db_pool_size: int = 5 db_pool_size: int = 5
db_pool_max_overflow: int = 10 db_pool_max_overflow: int = 10
# Configs da api class HolmesConfig(BaseModel):
host: str = '127.0.0.1' # no servidor use 0.0.0.0 pra aceitar conexões de qualquer máquina da rede token: str
port: int
settings = Settings() class APIConfig(BaseModel):
host: str
port: int
ambiente: str
workers: int
class Settings(BaseModel):
api: APIConfig
banco: BancoConfig
holmes: HolmesConfig
_PATH = Path(__file__).resolve().parents[2] / "config.json"
settings = Settings.model_validate_json(_PATH.read_text(encoding="utf-8"))

View file

@ -20,17 +20,17 @@ def _escapar(valor: str) -> str:
connection_string = ( connection_string = (
f"DRIVER={_escapar(settings.db_driver)};" f"DRIVER={_escapar(settings.banco.db_driver)};"
f"SERVER={settings.db_host},{settings.db_porta};" f"SERVER={settings.banco.db_host},{settings.banco.db_porta};"
f"DATABASE={_escapar(settings.db_database)};" f"DATABASE={_escapar(settings.banco.db_database)};"
f"UID={_escapar(settings.db_login)};" f"UID={_escapar(settings.banco.db_login)};"
f"PWD={_escapar(settings.db_senha.get_secret_value())};" f"PWD={_escapar(settings.banco.db_senha.get_secret_value())};"
) )
engine = create_engine( engine = create_engine(
URL.create('mssql+pyodbc', query={'odbc_connect': connection_string}), URL.create('mssql+pyodbc', query={'odbc_connect': connection_string}),
pool_size=settings.db_pool_size, # conexões mantidas abertas pool_size=settings.banco.db_pool_size, # conexões mantidas abertas
max_overflow=settings.db_pool_max_overflow, # extras permitidas em pico de acesso max_overflow=settings.banco.db_pool_max_overflow, # extras permitidas em pico de acesso
pool_pre_ping=True, # testa a conexão antes de entregar (o servidor pode ter derrubado) pool_pre_ping=True, # testa a conexão antes de entregar (o servidor pode ter derrubado)
pool_recycle=1800, # renova conexões com mais de 30 min pool_recycle=1800, # renova conexões com mais de 30 min
) )

37
app/utils/api_tracker.py Normal file
View file

@ -0,0 +1,37 @@
import logging
from sqlalchemy.pool import PoolProxiedConnection
def registrar_contador(
conn: PoolProxiedConnection,
api: str,
endpoint: str,
metodo: str,
status_code: int | None,
sucesso: bool,
duracao_ms: float,
erro: str | None = None,
) -> None:
"""Grava uma linha na tabela contadores_api. Falha aqui não derruba a chamada principal."""
cursor = conn.cursor()
try:
cursor.execute("""
INSERT INTO contadores_api
(api, endpoint, metodo_http, status_code, sucesso, duracao_ms, mensagem_erro)
VALUES (?, ?, ?, ?, ?, ?, ?)
""", (
api,
endpoint,
metodo,
status_code,
'S' if sucesso else 'N',
round(duracao_ms, 2),
erro[:500] if erro else None,
))
conn.commit()
except Exception as e:
conn.rollback()
logging.error(f'Falha ao gravar contador: {e}')
finally:
cursor.close()

644
app/utils/holmes.py Normal file
View file

@ -0,0 +1,644 @@
import asyncio
import logging
import os
import tempfile
import time
import httpx
from sqlalchemy.pool import PoolProxiedConnection
from app.core.configs import settings
from app.utils.api_tracker import registrar_contador
_TOKEN_FILE = os.path.join(tempfile.gettempdir(), "holmes_token_cache.json")
async def get_header() -> tuple[dict, str]:
return {"api_token": settings.holmes.token}, "holmes"
async def _holmes_request(
method: str, url: str, **kwargs
) -> tuple[httpx.Response, str]:
api_nome: str = "holmes"
for tentativa in range(2):
header, api_nome = await get_header()
async with httpx.AsyncClient() as client:
response = await getattr(client, method)(url, headers=header, **kwargs)
return response, api_nome
raise RuntimeError("Holmes: falha de autenticação após retry")
async def get_holmes_process(id_processo: str, conn: PoolProxiedConnection):
"""
Busca um processo no Holmes. Centralizado para Peças e Despesas.
"""
url = f"https://app-api.holmesdoc.io/v1/processes/{id_processo}"
inicio = time.perf_counter()
status = None
sucesso = False
erro = None
api_nome = "holmes"
try:
response, api_nome = await _holmes_request("get", url)
response.raise_for_status()
status = response.status_code
sucesso = True
return response.json()
except httpx.HTTPStatusError as e:
status = e.response.status_code
erro = str(e)
logging.error(f"Erro na API Holmes (ID {id_processo}): {e}")
return None
except Exception as e:
erro = str(e)
logging.error(f"Erro inesperado ao consultar Holmes: {e}")
return None
finally:
duracao = (time.perf_counter() - inicio) * 1000
registrar_contador(
conn=conn,
api=api_nome,
endpoint="/v1/processes/{id}",
metodo="GET",
status_code=status,
sucesso=sucesso,
duracao_ms=duracao,
erro=erro,
)
async def get_holmes_process_details(id_processo: str, conn: PoolProxiedConnection):
"""
Busca os detalhes (properties) de um processo no Holmes.
"""
url = f"https://app-api.holmesdoc.io/v1/processes/{id_processo}/details"
inicio = time.perf_counter()
status = None
sucesso = False
erro = None
api_nome = "holmes"
try:
response, api_nome = await _holmes_request("get", url)
response.raise_for_status()
status = response.status_code
sucesso = True
return response.json()
except httpx.HTTPStatusError as e:
status = e.response.status_code
erro = str(e)
logging.error(f"Erro na API Holmes details (ID {id_processo}): {e}")
return None
except Exception as e:
erro = str(e)
logging.error(f"Erro inesperado ao consultar Holmes details: {e}")
return None
finally:
duracao = (time.perf_counter() - inicio) * 1000
registrar_contador(
conn=conn,
api=api_nome,
endpoint="/v1/processes/{id}/details",
metodo="GET",
status_code=status,
sucesso=sucesso,
duracao_ms=duracao,
erro=erro,
)
async def get_holmes_history(id_processo: str, conn: PoolProxiedConnection):
"""
Busca o historico no holmes (importante para pegar o id da ultima task, para avançar futuramente)
Args:
id_processo (str): id do processo no holmes
"""
url = f"https://app-api.holmesdoc.io/v1/processes/{id_processo}/history"
payload = {
"filters": [],
"page": 1,
"per_page": 100,
"sortBy": ["created_at", "desc"],
}
inicio = time.perf_counter()
status = None
sucesso = False
erro = None
api_nome = "holmes"
try:
response, api_nome = await _holmes_request("post", url, json=payload)
response.raise_for_status()
status = response.status_code
sucesso = True
return response.json()
except httpx.HTTPStatusError as e:
status = e.response.status_code
erro = str(e)
logging.error(f"Erro na API Holmes (ID {id_processo}): {e}")
return None
except Exception as e:
erro = str(e)
logging.error(f"Erro inesperado ao consultar Holmes: {e}")
return None
finally:
duracao = (time.perf_counter() - inicio) * 1000
registrar_contador(
conn=conn,
api=api_nome,
endpoint="/v1/processes/{id}/history",
metodo="POST",
status_code=status,
sucesso=sucesso,
duracao_ms=duracao,
erro=erro,
)
async def get_holmes_rateio(id_processo: str, conn: PoolProxiedConnection):
url = f"https://app-api.holmesdoc.io/v1/processes/{id_processo}/tables/e124b2d0-ee14-11ef-95b4-25dee32fe73f/table_items?page=1&per_page=800"
inicio = time.perf_counter()
status = None
sucesso = False
erro = None
api_nome = "holmes"
try:
response, api_nome = await _holmes_request("get", url)
response.raise_for_status()
status = response.status_code
sucesso = True
return response.json()
except httpx.HTTPStatusError as e:
status = e.response.status_code
erro = str(e)
logging.error(f"Erro na API Holmes (ID {id_processo}): {e}")
return None
except Exception as e:
erro = str(e)
logging.error(f"Erro inesperado ao consultar Holmes: {e}")
return None
finally:
duracao = (time.perf_counter() - inicio) * 1000
registrar_contador(
conn=conn,
api=api_nome,
endpoint="/v1/processes/{id}/table/(rateio)",
metodo="GET",
status_code=status,
sucesso=sucesso,
duracao_ms=duracao,
erro=erro,
)
async def get_holmes_dados_tabela(id_processo: str, id_tabela: str, conn: PoolProxiedConnection):
url = f"https://app-api.holmesdoc.io/v1/processes/{id_processo}/tables/{id_tabela}/table_items?page=1&per_page=800"
inicio = time.perf_counter()
status = None
sucesso = False
erro = None
api_nome = "holmes"
try:
response, api_nome = await _holmes_request("get", url)
response.raise_for_status()
status = response.status_code
sucesso = True
return response.json()
except httpx.HTTPStatusError as e:
status = e.response.status_code
erro = str(e)
logging.error(f"Erro na API Holmes (ID {id_processo}): {e}")
return None
except Exception as e:
erro = str(e)
logging.error(f"Erro inesperado ao consultar Holmes: {e}")
return None
finally:
duracao = (time.perf_counter() - inicio) * 1000
registrar_contador(
conn=conn,
api=api_nome,
endpoint="/v1/processes/{id}/table/(colocar-tabela)",
metodo="GET",
status_code=status,
sucesso=sucesso,
duracao_ms=duracao,
erro=erro,
)
async def task_id_recente(id_processo: str, conn: PoolProxiedConnection):
dados_tasks = await get_holmes_history(id_processo, conn)
if (
not dados_tasks
or "histories" not in dados_tasks
or not dados_tasks["histories"]
):
return None
mais_recente = max(dados_tasks["histories"], key=lambda x: x["created_at"])
return mais_recente["properties"]["task_id"]
async def task_mais_recente(id_processo: str, conn: PoolProxiedConnection):
dados_tasks = await get_holmes_history(id_processo, conn)
if not dados_tasks or "histories" not in dados_tasks:
return None # Tratamento se a API falhar
# print(dados_tasks)
mais_recente = max(dados_tasks["histories"], key=lambda x: x["created_at"])
return mais_recente
async def historicos_task(id_processo: str, conn: PoolProxiedConnection) -> dict | None:
"""_summary_
Args:
id_processo (str): Id do processo no holmes
Returns:
dict | None : dicionario do historico | None
"""
dados_tasks = await get_holmes_history(id_processo, conn)
if not dados_tasks or "histories" not in dados_tasks:
return None # Tratamento se a API falhar
return dados_tasks
async def buscar_processo(
conn: PoolProxiedConnection,
chave: str | None = None,
fluxos: list[str] | bool = False,
ativos: bool = True,
payload: dict | bool = False,
) -> dict:
"""Obtem os processos que existem com a sua chave
Args:
chave (str): Chave principal a ser procurada, preferencialmente unica pfvr, ajuda ae po.
ativos (bool) Defaults to True
fluxos (list[str] | bool, optional): _description_. Defaults to False. se quer pegar de um fluxo específico ou geral. Padrão: Geral
Returns:
dict: _description_
"""
if not payload and chave is None:
raise ValueError(
"Chave é obrigatória caso o payload não seja enviado chefia, fica alerta ae rapa"
)
inicio = time.perf_counter()
status = None
sucesso = False
erro = None
api_nome = "holmes"
url = "https://app-api.holmesdoc.io/v2/search"
if not payload:
payload = {
"query": {
"from": 0,
"size": 200,
"context": "process",
"sort": "updated_at",
"order": "desc",
"groups": [
{
"match_all": True,
"terms": [
{
"value": f"{chave}",
"type": "match_phrase",
"field": "_content",
}
],
}
],
},
"trash": False,
"deleted_by_me": False,
}
try:
response, api_nome = await _holmes_request("post", url, json=payload)
response.raise_for_status()
status = response.status_code
sucesso = True
dados = response.json()
docs = dados.get("docs", [])
if ativos:
docs = [d for d in docs if d.get("status") != "canceled"]
if fluxos:
docs = [d for d in docs if d.get("name") in fluxos]
return {"status": True, "dados": {**dados, "docs": docs, "total": len(docs)}}
except httpx.HTTPStatusError as e:
status = e.response.status_code
erro = str(e)
logging.error(f"Erro na API Holmes (ID {chave}): {e}")
return {"status": False, "error": e}
except Exception as e:
erro = str(e)
logging.error(f"Erro inesperado ao consultar Holmes: {e}")
return {"status": False, "error": e}
finally:
duracao = (time.perf_counter() - inicio) * 1000
registrar_contador(
conn=conn,
api=api_nome,
endpoint="/v1/processes/{id}/search/por-chave",
metodo="POST",
status_code=status,
sucesso=sucesso,
duracao_ms=duracao,
erro=erro,
)
async def buscar_processo_por_chaves(
conn: PoolProxiedConnection,
combinacoes: list[list[str]],
fluxos: list[str] | bool = False,
ativos: bool = True,
) -> dict:
"""Busca processos no Holmes usando combinações de termos.
Cada item de combinacoes é uma lista de valores que juntos identificam
um processo único (ex: [cnpj, numero_nf]). Cada combinação vira um group
separado na query.
Args:
combinacoes: Ex: [["03657256000164", "19"], ["698cd1c570fd0f8f5f8436a4"]]
ativos: Ignora processos cancelados. Padrão: True.
fluxos: Filtra por nome de fluxo. Padrão: False (todos).
"""
url = "https://app-api.holmesdoc.io/v2/search"
inicio = time.perf_counter()
status = None
sucesso = False
erro = None
api_nome = "holmes"
payload = {
"query": {
"from": 0,
"size": 200,
"context": "process",
"sort": "updated_at",
"order": "desc",
"groups": [
{
"match_all": True,
"terms": [
{"value": termo, "type": "match_phrase", "field": "_content"}
for termo in combinacao
],
}
for combinacao in combinacoes
],
},
"trash": False,
"deleted_by_me": False,
}
try:
response, api_nome = await _holmes_request("post", url, json=payload)
response.raise_for_status()
status = response.status_code
sucesso = True
dados = response.json()
docs = dados.get("docs", [])
if ativos:
docs = [d for d in docs if d.get("status") != "canceled"]
if fluxos:
docs = [d for d in docs if d.get("name") in fluxos]
return {"status": True, "dados": {**dados, "docs": docs, "total": len(docs)}}
except httpx.HTTPStatusError as e:
status = e.response.status_code
erro = str(e)
logging.error(f"Erro na API Holmes (combinacoes {combinacoes}): {e}")
return {"status": False, "error": e}
except Exception as e:
erro = str(e)
logging.error(f"Erro inesperado ao consultar Holmes: {e}")
return {"status": False, "error": e}
finally:
duracao = (time.perf_counter() - inicio) * 1000
registrar_contador(
conn=conn,
api=api_nome,
endpoint="/v1/processes/{id}/search/por-chaves",
metodo="POST",
status_code=status,
sucesso=sucesso,
duracao_ms=duracao,
erro=erro,
)
async def action(payload: dict, id_task: str, id_processo: str, conn: PoolProxiedConnection):
url = f"https://app-api.holmesdoc.io/v1/tasks/{id_task}/action"
inicio = time.perf_counter()
status = None
sucesso = False
erro = None
api_nome = "holmes"
try:
async with httpx.AsyncClient() as client:
response = await client.post(
url, headers={"api_token": settings.holmes.token}, json=payload
)
response.raise_for_status()
status = response.status_code
sucesso = True
return True, response.json()
except httpx.HTTPStatusError as e:
status = e.response.status_code
erro = str(e)
logging.error(f"Erro na API Holmes (ID {id_processo}): {e}")
return False, e
except Exception as e:
erro = str(e)
logging.error(f"Erro inesperado ao consultar Holmes: {e}")
return False, e
finally:
duracao = (time.perf_counter() - inicio) * 1000
registrar_contador(
conn=conn,
api=api_nome,
endpoint="/v1/processes/{id}/action",
metodo="POST",
status_code=status,
sucesso=sucesso,
duracao_ms=duracao,
erro=erro,
)
async def cria_processo(
id_start: str,
payload: dict,
conn: PoolProxiedConnection
) -> tuple[bool, dict | str]:
url = f"https://app-api.holmesdoc.io/v1/workflows/{id_start}/start"
inicio = time.perf_counter()
status = None
sucesso = False
erro = None
api_nome = "holmes"
try:
response, api_nome = await _holmes_request("post", url, json=payload)
response.raise_for_status()
status = response.status_code
sucesso = True
return True, response.json()
except httpx.HTTPStatusError as e:
status = e.response.status_code
erro = str(e)
logging.error(f"Erro na API Holmes - Criar Processo ({payload}): {e}")
return False, str(e)
except Exception as e:
erro = str(e)
logging.error(f"Erro inesperado ao criar processo no Holmes: {e}")
return False, str(e)
finally:
duracao = (time.perf_counter() - inicio) * 1000
registrar_contador(
conn=conn,
api=api_nome,
endpoint="/v1/workflows/{id}/start",
metodo="POST",
status_code=status,
sucesso=sucesso,
duracao_ms=duracao,
erro=erro,
)
async def enviar_documento(
id_processo: str,
arquivo: bytes,
nome_arquivo: str,
id_documento: str,
conn: PoolProxiedConnection,
) -> tuple[bool, str | dict]:
task_id = await task_id_recente(id_processo, conn)
if not task_id:
return False, "Não foi possível obter a task mais recente do Holmes"
url = f"https://app-api.holmesdoc.io/v1/tasks/{task_id}/documents/{id_documento}"
inicio = time.perf_counter()
status = None
sucesso = False
erro = None
api_nome = "holmes"
try:
files = {"file": (nome_arquivo, arquivo, "application/pdf")}
async with httpx.AsyncClient() as client:
response = await client.post(
url, headers={"api_token": settings.holmes.token}, files=files
)
response.raise_for_status()
status = response.status_code
sucesso = True
return True, {"task_id": task_id}
except httpx.HTTPStatusError as e:
status = e.response.status_code
erro = str(e)
logging.error(f"Erro ao enviar documento Holmes (ID {id_processo}): {e}")
return False, str(e)
except Exception as e:
erro = str(e)
logging.error(f"Erro inesperado ao enviar documento Holmes: {e}")
return False, str(e)
finally:
duracao = (time.perf_counter() - inicio) * 1000
registrar_contador(
conn=conn,
api=api_nome,
endpoint="/v1/tasks/{id}/documents/{id_documento}",
metodo="POST",
status_code=status,
sucesso=sucesso,
duracao_ms=duracao,
erro=erro,
)
# Para testar as funcoes
# async def main():
# from app.infra.database import db_instance
# db_instance.create_pool()
# conn = db_instance.pool.acquire()
# try:
# print(await get_holmes_history('69e65ea83fad950fad5715ed', conn))
# finally:
# db_instance.pool.release(conn)
# if __name__ == '__main__':
# import asyncio
# asyncio.run(main())
async def cancela_processo(
id_processo: str, conn: PoolProxiedConnection
) -> tuple[bool, str | dict]:
url = f"https://app-api.holmesdoc.io/v1/processes/{id_processo}/cancel"
payload = {"reason": "Erro na emissão, data de vencimento. Problema na Disal."}
inicio = time.perf_counter()
status = None
sucesso = False
erro = None
api_nome = "holmes"
try:
response, api_nome = await _holmes_request("put", url, json=payload)
response.raise_for_status()
status = response.status_code
sucesso = True
return True, response.json() if response.content else {
"mensagem": "processo cancelado"
}
except httpx.HTTPStatusError as e:
status = e.response.status_code
erro = str(e)
logging.error(f"Erro ao cancelar processo Holmes (ID {id_processo}): {e}")
return False, str(e)
except Exception as e:
erro = str(e)
logging.error(f"Erro inesperado ao cancelar processo Holmes: {e}")
return False, str(e)
finally:
duracao = (time.perf_counter() - inicio) * 1000
registrar_contador(
conn=conn,
api=api_nome,
endpoint="/v1/processes/{id}/cancel",
metodo="PUT",
status_code=status,
sucesso=sucesso,
duracao_ms=duracao,
erro=erro,
)
async def main():
# print(aaaa())
print(await token_usuario())
if __name__ == "__main__":
import asyncio
asyncio.run(main())

View file

@ -1,6 +1,8 @@
from fastapi import APIRouter, HTTPException, status from fastapi import APIRouter, HTTPException, status
from fastapi.concurrency import run_in_threadpool
from app.core.database import Conexao from app.core.database import Conexao
from app.utils.holmes import get_holmes_history
from app.v1.modules.escrituracao.models.modelo_notas import NotasHolmesInput from app.v1.modules.escrituracao.models.modelo_notas import NotasHolmesInput
from app.v1.modules.escrituracao.service import NotasDespesas from app.v1.modules.escrituracao.service import NotasDespesas
@ -12,15 +14,19 @@ escrituracao_router = APIRouter(
@escrituracao_router.post( @escrituracao_router.post(
path='/notas_despesas' path='/notas_despesas'
) )
def inserir_nota_despesas( async def inserir_nota_despesas(
dados_nota_holmes: NotasHolmesInput, dados_nota_holmes: NotasHolmesInput,
conexao: Conexao, conexao: Conexao,
): ):
repo = NotasDespesas(conexao) repo = NotasDespesas(conexao)
# History traz a hora de cada "Aprovar"; se o Holmes falhar, volta None e grava só Feito / Não Feito
historico = await get_holmes_history(dados_nota_holmes.id, conexao)
try: try:
acao = repo.inserir_nota_despesas(dados_nota_holmes) # O banco é síncrono: roda fora do event loop pra não travar as outras requisições
acao = await run_in_threadpool(repo.inserir_nota_despesas, dados_nota_holmes, historico)
except ValueError as erro: except ValueError as erro:
raise HTTPException( raise HTTPException(
status_code= status.HTTP_422_UNPROCESSABLE_ENTITY, status_code= status.HTTP_422_UNPROCESSABLE_ENTITY,

View file

@ -1,11 +1,14 @@
import json import json
from datetime import date from datetime import date, datetime, timedelta, timezone
from decimal import ROUND_HALF_UP, Decimal from decimal import ROUND_HALF_UP, Decimal
from sqlalchemy.pool import PoolProxiedConnection from sqlalchemy.pool import PoolProxiedConnection
from app.v1.modules.escrituracao.models.modelo_notas import NotasHolmesInput 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: class NotasDespesas:
def __init__(self, conexao: PoolProxiedConnection) -> None: def __init__(self, conexao: PoolProxiedConnection) -> None:
@ -52,7 +55,7 @@ class NotasDespesas:
continue continue
etapa, status = (parte.strip() for parte in linha.rsplit('—', 1)) etapa, status = (parte.strip() for parte in linha.rsplit('—', 1))
etapa = etapa.upper() etapa = etapa.upper()
if 'ADM LOJA' in etapa: if 'ADM' in etapa: # ADM LOJA, ADM MATRIZ...
aprovacoes['adm_loja'] = status aprovacoes['adm_loja'] = status
elif 'CONTROLADOR' in etapa: elif 'CONTROLADOR' in etapa:
aprovacoes['controladoria'] = status aprovacoes['controladoria'] = status
@ -62,7 +65,40 @@ class NotasDespesas:
aprovacoes['gerente'] = status aprovacoes['gerente'] = status
return aprovacoes return aprovacoes
def inserir_nota_despesas(self, nota: NotasHolmesInput) -> str: @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 props = nota.properties
datas = sorted( datas = sorted(
@ -79,10 +115,12 @@ class NotasDespesas:
valor = Decimal(str(props.valor)).quantize(Decimal('0.01'), rounding=ROUND_HALF_UP) valor = Decimal(str(props.valor)).quantize(Decimal('0.01'), rounding=ROUND_HALF_UP)
vencimentos_json = json.dumps(self.montar_vencimentos(valor, datas)) vencimentos_json = json.dumps(self.montar_vencimentos(valor, datas))
situacao = self.traduzir_aprovacao(props.aprovacao) situacao = self.traduzir_aprovacao(props.aprovacao)
apr = self.extrair_aprovacoes(situacao) apr = self.montar_aprovacoes(self.extrair_aprovacoes(situacao), historico)
cursor = self.conexao.cursor() cursor = self.conexao.cursor()
# A mesma nota pode chegar mais de uma vez: se já existe, atualiza # 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(""" cursor.execute("""
UPDATE PD_HOLMES_APOLLO UPDATE PD_HOLMES_APOLLO
SET SET
@ -96,10 +134,10 @@ class NotasDespesas:
ORIGEM = ?, ORIGEM = ?,
cpfcnpj = ?, cpfcnpj = ?,
observacao = ?, observacao = ?,
apr_gerente = ?, apr_gerente = CASE WHEN ? = 1 THEN COALESCE(CAST(? AS datetime), apr_gerente, GETDATE()) END,
apr_adm_loja = ?, apr_adm_loja = CASE WHEN ? = 1 THEN COALESCE(CAST(? AS datetime), apr_adm_loja, GETDATE()) END,
apr_controladoria = ?, apr_controladoria = CASE WHEN ? = 1 THEN COALESCE(CAST(? AS datetime), apr_controladoria, GETDATE()) END,
apr_contas_pagar = ? apr_contas_pagar = CASE WHEN ? = 1 THEN COALESCE(CAST(? AS datetime), apr_contas_pagar, GETDATE()) END
WHERE ID_HOLMES = ? WHERE ID_HOLMES = ?
""", ( """, (
props.empresa, props.empresa,
@ -112,10 +150,7 @@ class NotasDespesas:
props.origem, props.origem,
props.cpf_cnpj, props.cpf_cnpj,
props.observacao, props.observacao,
apr['gerente'], *apr,
apr['adm_loja'],
apr['controladoria'],
apr['contas_pagar'],
nota.id, nota.id,
)) ))
@ -137,12 +172,18 @@ class NotasDespesas:
VALOR_NOTA, VALOR_NOTA,
VENCIMENTOS_JSON, VENCIMENTOS_JSON,
ORIGEM, ORIGEM,
observacao,
apr_gerente, apr_gerente,
apr_adm_loja, apr_adm_loja,
apr_controladoria, apr_controladoria,
apr_contas_pagar, apr_contas_pagar
observacao ) VALUES (
) 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, nota.id,
props.protocolo, props.protocolo,
@ -156,11 +197,8 @@ class NotasDespesas:
valor, valor,
vencimentos_json, vencimentos_json,
props.origem, props.origem,
apr['gerente'],
apr['adm_loja'],
apr['controladoria'],
apr['contas_pagar'],
props.observacao, props.observacao,
*apr,
)) ))
self.conexao.commit() self.conexao.commit()

21
config.example.json Normal file
View file

@ -0,0 +1,21 @@
{
"api": {
"host": "0.0.0.0",
"port": 8000,
"ambiente": "homolog",
"workers": 1
},
"banco": {
"db_host": "IP_DO_SQL_SERVER",
"db_porta": 1433,
"db_database": "APP_GESTAO",
"db_login": "USUARIO",
"db_senha": "SENHA",
"db_driver": "ODBC Driver 17 for SQL Server",
"db_pool_size": 5,
"db_pool_max_overflow": 10
},
"holmes": {
"token": "TOKEN_DO_HOLMES"
}
}

View file

@ -32,4 +32,4 @@ def dados_retorno(dados_retorno: dict):
logger.info(json.dumps(dados_retorno, ensure_ascii=False)) logger.info(json.dumps(dados_retorno, ensure_ascii=False))
if __name__ == '__main__': if __name__ == '__main__':
uvicorn.run(app, host=settings.host, port=settings.port) uvicorn.run(app, host=settings.api.host, port=settings.api.port)