Conector Scardua — recebe da API da FLS e entrega no Oracle do cliente

Servico que roda dentro da rede da Comercial Scardua e faz a ponte entre a
API publica da FLS (na VPS) e o Oracle privado (10.16.x), inalcancavel pela
internet.

Fluxo: Holmes -> API na VPS (trata e cifra) -> ESTE conector (abre e valida)
-> Oracle.

Recebimento:
- app/v1/compras.py: POST /v1/compras/dados
- app/services/cripto.py: abre o envelope AES-256-GCM + RSA-OAEP-SHA256 com a
  chave privada. O GCM autentica: corpo adulterado levanta InvalidTag em vez
  de devolver lixo
- app/schemas.py: modulo folha (so pydantic) com a config e o contrato
  PayloadCompras, que espelha o da API. Fora de sincronia devolve 422 de
  proposito, pra falhar explicito em vez de gravar dado torto

Seguranca:
- app/seguranca.py: header X-Token com compare_digest (nao vaza por tempo de
  resposta) + allowlist de IP da VPS
- .gitignore barra configs.json.*, *.bak-*, *.pem e *.key

Config:
- app/config.py e so o carregamento do configs.json
- o bloco "vps" guarda chave privada, token e ips permitidos

Estado: ainda NAO persiste. Recebe, valida e descarta (persistido: false).
O INSERT no Oracle e a proxima fase, e tem que ser MERGE por id_processo
porque o Holmes reentrega webhook.

Docs em docs/ — arquitetura, a decisao do conector (opcao A, com as
alternativas descartadas), deploy e problemas conhecidos.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

main.py

@@ -0,0 +1,108 @@
+import json
+import logging
+import secrets
+
+from app.config import settings
+from app.middleware import block_scanners
+from app.v1.api import api_router
+from fastapi import Depends, FastAPI, HTTPException, status
+from fastapi.openapi.docs import get_redoc_html, get_swagger_ui_html
+from fastapi.security import HTTPBasic, HTTPBasicCredentials
+
+# --- Logging da aplicacao ---
+# Sem isto, os logging.info(...) das rotas sao engolidos: o root logger vem em
+# WARNING por padrao, entao INFO nao aparece no `podman logs`.
+logging.basicConfig(
+    level=settings.log_level,
+    format="%(asctime)s %(levelname)s %(message)s",
+)
+
+
+# Filtra o acesso do healthcheck (/health a cada 30s) pra nao poluir o log.
+class _FiltraHealthAccess(logging.Filter):
+    def filter(self, record: logging.LogRecord) -> bool:
+        return "/health" not in record.getMessage()
+
+
+logging.getLogger("uvicorn.access").addFilter(_FiltraHealthAccess())
+
+is_prod = settings.api.ambiente.lower() == "prod"
+
+app = FastAPI(
+    title='API - Scardua',
+    version='0.0.1',
+    docs_url=None,
+    redoc_url=None,
+    openapi_url=None,
+)
+
+app.middleware("http")(block_scanners)
+app.include_router(api_router, prefix="/v1")
+
+# --- Documentação protegida por login/senha (somente fora de produção) ---
+if not is_prod:
+    _docs_security = HTTPBasic()
+
+    def _verificar_docs(
+        credenciais: HTTPBasicCredentials = Depends(_docs_security),
+    ) -> str:
+        usuario_ok = secrets.compare_digest(
+            credenciais.username.encode("utf-8"),
+            settings.docs.user.encode("utf-8"),
+        )
+        senha_ok = secrets.compare_digest(
+            credenciais.password.encode("utf-8"),
+            settings.docs.password.encode("utf-8"),
+        )
+        if not (usuario_ok and senha_ok):
+            raise HTTPException(
+                status_code=status.HTTP_401_UNAUTHORIZED,
+                detail="Credenciais inválidas",
+                headers={"WWW-Authenticate": "Basic"},
+            )
+        return credenciais.username
+
+    @app.get("/openapi.json", include_in_schema=False)
+    def _openapi_protegido(_: str = Depends(_verificar_docs)):
+        return app.openapi()
+
+    @app.get("/docs", include_in_schema=False)
+    def _swagger_protegido(_: str = Depends(_verificar_docs)):
+        return get_swagger_ui_html(openapi_url="/openapi.json", title=app.title)
+
+    @app.get("/redoc", include_in_schema=False)
+    def _redoc_protegido(_: str = Depends(_verificar_docs)):
+        return get_redoc_html(openapi_url="/openapi.json", title=app.title)
+
+@app.get("/health", include_in_schema=False)
+def health():
+    """Healthcheck usado pelo Podman (auto-update / rollback)."""
+    return {"status": "ok"}
+
+
+@app.post('/dados_retorno')
+def dados_retorno(dados_retorno: dict):
+    """
+    Rota para vizualizar qualquer retorno do holmes
+    """
+    logging.info("Dados retornados do teste")
+    logging.info(json.dumps(dados_retorno, ensure_ascii=False))
+    return dados_retorno
+
+if __name__ == "__main__":
+    import uvicorn
+
+    port = settings.api.port
+    ambiente = settings.api.ambiente
+    workers = settings.api.workers
+    is_reload = ambiente.lower() != "prod"
+
+    logging.info("API ligada.")
+    uvicorn.run(
+        "main:app",
+        host="0.0.0.0",
+        port=port,
+        log_level="info",
+        workers=workers,
+        reload=is_reload,
+    )