4d47887c00
A API deixa de ser especifica da Scardua e passa a atender varios
clientes pela rota /v1/holmes/{cliente}/...
Camada de clientes:
- app/clientes/base.py: ClienteBase (comportamento) + ClienteConfig (dado),
separados de proposito — config sai do configs.json hoje e pode sair do
banco amanha sem o resto mudar
- app/clientes/registry.py: resolve o {cliente} da rota pra instancia
- cada cliente traz a propria conta do Holmes; o cache de token virou um
arquivo por cliente (antes era constante de modulo e dois clientes
sobrescreveriam o token um do outro)
Holmes:
- funcoes de modulo viraram a classe HolmesAPI, amarrada a uma conta
- exposta pronta em cliente.holmes (cached_property)
- as funcoes de parsing puro (extrair_*) ficaram fora da classe
Config:
- app/schemas.py: modulo folha, so pydantic. Config e services usam os
mesmos modelos sem um importar o outro
- app/config.py: so o carregamento do configs.json
- configs.json passa a ter "clientes": {"<nome>": {...}}
Compras:
- schemas aceitam o payload real do Holmes (PEDIDO_LINX vem como numero,
NUMERO NF ENTRADA so existe depois da fase da nota)
- parcelas viram dict[int, Parcela], pareando parcelaN com o vencimento
correspondente e pulando os slots vazios
- payload de saida carrega id_processo como chave de deduplicacao: o
Holmes reentrega webhook e sem isso duplica linha no destino
Criptografia:
- app/services/cripto.py: envelope AES-256-GCM + RSA-OAEP-SHA256. RSA
sozinho nao serve (cifra ~190 bytes; o payload passa disso)
- ciframos com a publica do conector e nao conseguimos desfazer
Deploy:
- Dockerfile e .dockerignore vieram da VPS pro repo
- docs/deploy.md: runbook, incluindo que --format docker e obrigatorio
(em OCI o podman ignora o HEALTHCHECK silenciosamente)
Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
63 lines
1.8 KiB
Python
63 lines
1.8 KiB
Python
import os
|
|
import tempfile
|
|
from abc import ABC
|
|
from functools import cached_property
|
|
|
|
from app.schemas import HolmesCliente
|
|
from app.services.holmes import HolmesAPI
|
|
from pydantic import BaseModel
|
|
|
|
|
|
class ClienteConfig(BaseModel):
|
|
nome: str
|
|
razao_social: str
|
|
cnpj: str
|
|
holmes: HolmesCliente
|
|
# Chave publica (PEM) da API do cliente. Ciframos com ela; so a privada,
|
|
# que fica com eles, abre.
|
|
chave_publica: str
|
|
|
|
|
|
class ClienteBase(ABC):
|
|
# A subclasse atribui direto: config = ClienteConfig(...)
|
|
config: ClienteConfig
|
|
|
|
def __init_subclass__(cls, **kwargs):
|
|
super().__init_subclass__(**kwargs)
|
|
if not hasattr(cls, "config"):
|
|
raise TypeError(f"{cls.__name__} precisa definir `config`")
|
|
|
|
# --- comum a todos: ninguem sobrescreve ---
|
|
|
|
@property
|
|
def nome(self) -> str:
|
|
return self.config.nome
|
|
|
|
@cached_property
|
|
def holmes(self) -> HolmesAPI:
|
|
"""
|
|
API do Holmes ja amarrada nas credenciais deste cliente.
|
|
|
|
cached_property e nao property: uma instancia por cliente, criada no
|
|
primeiro uso. Com @property comum sairia uma HolmesAPI nova a cada
|
|
acesso, e qualquer estado em memoria (token) se perderia.
|
|
"""
|
|
return HolmesAPI(
|
|
credenciais=self.config.holmes,
|
|
cache_token=self.cache_token_holmes,
|
|
)
|
|
|
|
@property
|
|
def cache_token_holmes(self) -> str:
|
|
"""
|
|
Arquivo de cache do token do Holmes, um por cliente.
|
|
|
|
Sem isso dois clientes com contas diferentes sobrescreveriam o token
|
|
um do outro — era o caso quando isso era uma constante de modulo.
|
|
"""
|
|
return os.path.join(
|
|
tempfile.gettempdir(), f"holmes_token_{self.nome}.json"
|
|
)
|
|
|
|
def __repr__(self) -> str:
|
|
return f"<Cliente {self.nome}>"
|