From 8986e3ce037999e22ffcb3b5148c13b3590ad35d Mon Sep 17 00:00:00 2001 From: Ricardo Date: Thu, 8 Oct 2026 14:05:29 -0300 Subject: [PATCH] =?UTF-8?q?Datas=20de=20aprova=C3=A7=C3=A3o=20pelo=20histo?= =?UTF-8?q?ry=20do=20Holmes=20e=20config=20em=20JSON?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - 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) --- .env.example | 13 - .gitignore | 3 +- app/core/configs.py | 38 +- app/core/database.py | 14 +- app/utils/api_tracker.py | 37 ++ app/utils/holmes.py | 644 +++++++++++++++++++++++++ app/v1/modules/escrituracao/router.py | 14 +- app/v1/modules/escrituracao/service.py | 78 ++- config.example.json | 21 + main.py | 2 +- 10 files changed, 798 insertions(+), 66 deletions(-) delete mode 100644 .env.example create mode 100644 app/utils/api_tracker.py create mode 100644 app/utils/holmes.py create mode 100644 config.example.json diff --git a/.env.example b/.env.example deleted file mode 100644 index 78c513c..0000000 --- a/.env.example +++ /dev/null @@ -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 diff --git a/.gitignore b/.gitignore index 3c204ca..8cf2b73 100644 --- a/.gitignore +++ b/.gitignore @@ -3,4 +3,5 @@ __pycache__/ *.pyc *.pyo -*.log \ No newline at end of file +*.log +config.json \ No newline at end of file diff --git a/app/core/configs.py b/app/core/configs.py index 1b141a1..cbb73e9 100644 --- a/app/core/configs.py +++ b/app/core/configs.py @@ -1,34 +1,32 @@ from pathlib import Path -from pydantic import 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] +from pydantic import BaseModel, SecretStr -class Settings(BaseSettings): - 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 +class BancoConfig(BaseModel): db_host: str db_porta: int = 1433 db_database: 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' - # Pool de conexões db_pool_size: int = 5 db_pool_max_overflow: int = 10 - # Configs da api - host: str = '127.0.0.1' # no servidor use 0.0.0.0 pra aceitar conexões de qualquer máquina da rede - port: int +class HolmesConfig(BaseModel): + token: str + +class APIConfig(BaseModel): + host: str + port: int + ambiente: str + workers: int -settings = Settings() \ No newline at end of file +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")) \ No newline at end of file diff --git a/app/core/database.py b/app/core/database.py index 7a5d5a4..b93ba40 100644 --- a/app/core/database.py +++ b/app/core/database.py @@ -20,17 +20,17 @@ def _escapar(valor: str) -> str: connection_string = ( - f"DRIVER={_escapar(settings.db_driver)};" - f"SERVER={settings.db_host},{settings.db_porta};" - f"DATABASE={_escapar(settings.db_database)};" - f"UID={_escapar(settings.db_login)};" - f"PWD={_escapar(settings.db_senha.get_secret_value())};" + f"DRIVER={_escapar(settings.banco.db_driver)};" + f"SERVER={settings.banco.db_host},{settings.banco.db_porta};" + f"DATABASE={_escapar(settings.banco.db_database)};" + f"UID={_escapar(settings.banco.db_login)};" + f"PWD={_escapar(settings.banco.db_senha.get_secret_value())};" ) engine = create_engine( URL.create('mssql+pyodbc', query={'odbc_connect': connection_string}), - pool_size=settings.db_pool_size, # conexões mantidas abertas - max_overflow=settings.db_pool_max_overflow, # extras permitidas em pico de acesso + pool_size=settings.banco.db_pool_size, # conexões mantidas abertas + 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_recycle=1800, # renova conexões com mais de 30 min ) diff --git a/app/utils/api_tracker.py b/app/utils/api_tracker.py new file mode 100644 index 0000000..29c8459 --- /dev/null +++ b/app/utils/api_tracker.py @@ -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() diff --git a/app/utils/holmes.py b/app/utils/holmes.py new file mode 100644 index 0000000..fd4c128 --- /dev/null +++ b/app/utils/holmes.py @@ -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()) diff --git a/app/v1/modules/escrituracao/router.py b/app/v1/modules/escrituracao/router.py index bb58ea5..402f4eb 100644 --- a/app/v1/modules/escrituracao/router.py +++ b/app/v1/modules/escrituracao/router.py @@ -1,6 +1,8 @@ from fastapi import APIRouter, HTTPException, status +from fastapi.concurrency import run_in_threadpool 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.service import NotasDespesas @@ -12,15 +14,19 @@ escrituracao_router = APIRouter( @escrituracao_router.post( path='/notas_despesas' ) -def inserir_nota_despesas( +async def inserir_nota_despesas( dados_nota_holmes: NotasHolmesInput, conexao: 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: - 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: raise HTTPException( status_code= status.HTTP_422_UNPROCESSABLE_ENTITY, @@ -29,4 +35,4 @@ def inserir_nota_despesas( return { 'mensagem': f'Nota {acao}' - } \ No newline at end of file + } diff --git a/app/v1/modules/escrituracao/service.py b/app/v1/modules/escrituracao/service.py index e2784ef..34d2760 100644 --- a/app/v1/modules/escrituracao/service.py +++ b/app/v1/modules/escrituracao/service.py @@ -1,11 +1,14 @@ import json -from datetime import date +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: @@ -52,7 +55,7 @@ class NotasDespesas: continue etapa, status = (parte.strip() for parte in linha.rsplit('—', 1)) etapa = etapa.upper() - if 'ADM LOJA' in etapa: + if 'ADM' in etapa: # ADM LOJA, ADM MATRIZ... aprovacoes['adm_loja'] = status elif 'CONTROLADOR' in etapa: aprovacoes['controladoria'] = status @@ -62,7 +65,40 @@ class NotasDespesas: aprovacoes['gerente'] = status 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 datas = sorted( @@ -79,10 +115,12 @@ class NotasDespesas: 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.extrair_aprovacoes(situacao) + 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 + # 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 @@ -96,10 +134,10 @@ class NotasDespesas: ORIGEM = ?, cpfcnpj = ?, observacao = ?, - apr_gerente = ?, - apr_adm_loja = ?, - apr_controladoria = ?, - apr_contas_pagar = ? + 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, @@ -112,10 +150,7 @@ class NotasDespesas: props.origem, props.cpf_cnpj, props.observacao, - apr['gerente'], - apr['adm_loja'], - apr['controladoria'], - apr['contas_pagar'], + *apr, nota.id, )) @@ -137,12 +172,18 @@ class NotasDespesas: VALOR_NOTA, VENCIMENTOS_JSON, ORIGEM, + observacao, apr_gerente, apr_adm_loja, apr_controladoria, - apr_contas_pagar, - observacao - ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?) + 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, @@ -156,11 +197,8 @@ class NotasDespesas: valor, vencimentos_json, props.origem, - apr['gerente'], - apr['adm_loja'], - apr['controladoria'], - apr['contas_pagar'], props.observacao, + *apr, )) self.conexao.commit() diff --git a/config.example.json b/config.example.json new file mode 100644 index 0000000..c2d6484 --- /dev/null +++ b/config.example.json @@ -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" + } +} diff --git a/main.py b/main.py index 6517327..c86193d 100644 --- a/main.py +++ b/main.py @@ -32,4 +32,4 @@ def dados_retorno(dados_retorno: dict): logger.info(json.dumps(dados_retorno, ensure_ascii=False)) if __name__ == '__main__': - uvicorn.run(app, host=settings.host, port=settings.port) \ No newline at end of file + uvicorn.run(app, host=settings.api.host, port=settings.api.port) \ No newline at end of file