@danhachuel/prodmaker 0.1.7 → 0.1.8

package/CHANGELOG.md

@@ -3,6 +3,26 @@
 Todas as versões seguem a etiqueta visual `MAJOR.MINOR.PATCH` com patch de dois dígitos
 (o registry NPM normaliza `0.1.00` → `0.1.0`).
 
+## 0.1.08 — 2026-10-30
+
+- **Parte 6 — Minhas Vendas & Conversões GCLID.**
+- **Vendas funcionais:** tabela com cards (vendas aprovadas, receita, comissão, conversões
+  pendentes), adição manual, **importação CSV** (colunas em ordem livre + upload de arquivo),
+  exclusão e filtro por status de conversão.
+- **Webhooks de venda públicos:** `POST /api/webhook/sale/{hotmart|clickbank|digistore24|
+  kiify|cakto}` com parser **tolerante** (percorre o JSON procurando valor, comissão, e-mail,
+  transação, GCLID, produto e status — cada plataforma usa nomes diferentes; aceita JSON e form).
+  Página lista as URLs prontas para copiar no postback de cada plataforma.
+- **Matching por GCLID:** ao registrar venda com GCLID, o sistema cruza com a visita
+  correspondente na tabela `visitas` (página, IP, origem) e marca 🎯 no GCLID rastreado.
+- **Conversões offline (GCLID):** enxuta implementação REST `uploadClickConversions`
+  (`services/gads.py`): refresh token OAuth → POST Google Ads API (versão configurável,
+  default v22); upload individual ou **em lote** das pendentes; status por venda
+  (pendente/enviada/erro) com erro atribuído; exige Google Ads completo em Chaves de API
+  (developer token, client, refresh token, customer_id e **conversion_action**).
+- Nova tabela `vendas` (com índices em gclid/created_at). Sem novas dependências Python
+  (upload via httpx já incluso).
+
 ## 0.1.07 — 2026-10-27
 
 - **Código de Ativação Mestre:** o login local agora valida o código de verdade.

package/app/api/vendas.py

@@ -0,0 +1,167 @@
+import json
+
+from fastapi import APIRouter, HTTPException, Request
+from fastapi.responses import Response
+from pydantic import BaseModel
+
+from ..services import gads, vendas
+from ..services.database import get_db, now_str, row_to_dict
+from ..services.llm import LLMError
+
+router = APIRouter(prefix="/api", tags=["vendas"])
+
+WEBHOOK_FONTES = ("hotmart", "clickbank", "digistore24", "kiify", "cakto")
+
+
+class VendaBody(BaseModel):
+    produto_nome: str = ""
+    produto_id: int | None = None
+    valor: float = 0
+    comissao: float = 0
+    gclid: str = ""
+    comprador_email: str = ""
+    transacao_id: str = ""
+
+
+class CsvBody(BaseModel):
+    csv: str
+
+
+# ---------------------------------------------------------------------------
+# Vendas
+# ---------------------------------------------------------------------------
+
+
+@router.get("/vendas")
+def list_vendas():
+    return vendas.list_vendas()
+
+
+@router.get("/vendas/resumo")
+def resumo_vendas():
+    return vendas.resumo()
+
+
+@router.post("/vendas")
+def create_venda(body: VendaBody):
+    if not body.produto_nome.strip():
+        raise HTTPException(status_code=400, detail="Informe o nome do produto.")
+    return vendas.registrar_venda(
+        {
+            "fonte": "manual",
+            "produto_id": body.produto_id,
+            "produto_nome": body.produto_nome.strip(),
+            "valor": body.valor,
+            "comissao": body.comissao or round(body.valor * 0.5, 2),
+            "gclid": body.gclid.strip(),
+            "comprador_email": body.comprador_email.strip(),
+            "transacao_id": body.transacao_id.strip(),
+            "status": "aprovada",
+        }
+    )
+
+
+@router.delete("/vendas/{venda_id}")
+def delete_venda(venda_id: int):
+    vendas.delete_venda(venda_id)
+    return {"ok": True}
+
+
+@router.post("/vendas/csv")
+def importar_csv(body: CsvBody):
+    if not body.csv.strip():
+        raise HTTPException(status_code=400, detail="CSV vazio.")
+    try:
+        return vendas.importar_csv(body.csv)
+    except LLMError as exc:
+        raise HTTPException(status_code=400, detail=str(exc))
+
+
+# ---------------------------------------------------------------------------
+# Conversões GCLID (upload offline ao Google Ads)
+# ---------------------------------------------------------------------------
+
+
+@router.post("/vendas/{venda_id}/conversao")
+def upload_conversao(venda_id: int):
+    venda = vendas.get_venda(venda_id)
+    if venda["conversao_status"] == "enviada":
+        raise HTTPException(status_code=400, detail="Conversão desta venda já foi enviada.")
+    try:
+        resultado = gads.upload_conversao(venda["gclid"], venda["valor"], venda["created_at"])
+    except LLMError as exc:
+        vendas.marcar_conversao(venda_id, "erro", str(exc))
+        raise HTTPException(status_code=400, detail=str(exc))
+    vendas.marcar_conversao(venda_id, "enviada")
+    return {"ok": True, "venda": vendas.get_venda(venda_id), "resultado": resultado}
+
+
+@router.post("/vendas/conversoes/upload")
+def upload_conversoes_pendentes():
+    """Envia todas as vendas aprovadas com GCLID cuja conversão ainda está pendente."""
+    enviadas = []
+    erros = []
+    with get_db() as conn:
+        rows = conn.execute(
+            "SELECT * FROM vendas WHERE status = 'aprovada' AND gclid != '' AND conversao_status != 'enviada' ORDER BY id"
+        ).fetchall()
+    for row in rows:
+        venda = row_to_dict(row)
+        try:
+            gads.upload_conversao(venda["gclid"], venda["valor"], venda["created_at"])
+            vendas.marcar_conversao(venda["id"], "enviada")
+            enviadas.append(venda["id"])
+        except LLMError as exc:
+            vendas.marcar_conversao(venda["id"], "erro", str(exc))
+            erros.append(f"#{venda['id']}: {exc}")
+    return {"enviadas": enviadas, "erros": erros}
+
+
+# ---------------------------------------------------------------------------
+# Webhooks de vendas (públicos — POST das plataformas de afiliados)
+# ---------------------------------------------------------------------------
+
+
+@router.options("/webhook/sale/{fonte}")
+def webhook_options(fonte: str):
+    return Response(
+        status_code=204,
+        headers={
+            "Access-Control-Allow-Origin": "*",
+            "Access-Control-Allow-Methods": "POST, OPTIONS",
+            "Access-Control-Allow-Headers": "*",
+        },
+    )
+
+
+@router.post("/webhook/sale/{fonte}")
+async def webhook_sale(fonte: str, request: Request):
+    fonte = fonte.lower()
+    if fonte not in WEBHOOK_FONTES:
+        raise HTTPException(status_code=404, detail=f"Fonte desconhecida. Suportadas: {', '.join(WEBHOOK_FONTES)}")
+    raw = await request.body()
+    payload = None
+    try:
+        parsed = json.loads(raw)
+        if isinstance(parsed, dict):
+            payload = parsed
+    except Exception:
+        pass
+    if payload is None:
+        # Plataformas que postam em application/x-www-form-urlencoded
+        from urllib.parse import parse_qs
+
+        form = parse_qs(raw.decode("utf-8", errors="replace"))
+        payload = {key: values[0] if len(values) == 1 else values for key, values in form.items()}
+    if not payload:
+        raise HTTPException(status_code=400, detail="Payload vazio ou não reconhecido (envie JSON ou form-urlencoded).")
+    try:
+        data = vendas.parse_webhook(fonte, payload)
+    except Exception as exc:  # noqa: BLE001
+        raise HTTPException(status_code=400, detail=f"Payload não processado: {exc}")
+    venda = vendas.registrar_venda(data)
+    return Response(
+        content=json.dumps({"ok": True, "id": venda["id"]}, ensure_ascii=False),
+        media_type="application/json",
+        headers={"Access-Control-Allow-Origin": "*"},
+    )

package/app/main.py

@@ -15,7 +15,7 @@ from .services.database import ensure_db, get_db, now_str, row_to_dict
 from .services.llm import LLMError, analyze_product, list_providers
 from .services.store import PRODMAKER_HOME, STORAGE, STATE, ensure_state_dir, get_master_code, get_settings, save_settings
 
-APP_VERSION = "0.1.07"
+APP_VERSION = "0.1.08"
 COOKIE_NAME = "prodmaker_session"
 SESSION_DAYS = 30
 MASTER_ALIAS = "admin"
@@ -30,12 +30,14 @@ from .api import llm as llm_router  # noqa: E402
 from .api import paginas as paginas_router  # noqa: E402
 from .api import dominios as dominios_router  # noqa: E402
 from .api import tracking as tracking_router  # noqa: E402
+from .api import vendas as vendas_router  # noqa: E402
 
 app.include_router(llm_router.router)
 app.include_router(infoprodutos_router.router)
 app.include_router(paginas_router.router)
 app.include_router(dominios_router.router)
 app.include_router(tracking_router.router)
+app.include_router(vendas_router.router)
 
 ensure_db()
 
@@ -242,7 +244,7 @@ def health():
 
 @app.get("/api/version")
 def version():
-    return {"version": APP_VERSION, "canonical": "0.1.7"}
+    return {"version": APP_VERSION, "canonical": "0.1.8"}
 
 
 @app.get("/api/settings")

package/app/services/database.py

@@ -97,6 +97,33 @@ def ensure_db() -> None:
             )
             """
         )
+        conn.execute(
+            """
+            CREATE TABLE IF NOT EXISTS vendas (
+                id INTEGER PRIMARY KEY AUTOINCREMENT,
+                fonte TEXT NOT NULL DEFAULT 'manual',
+                produto_id INTEGER,
+                produto_nome TEXT NOT NULL DEFAULT '',
+                transacao_id TEXT NOT NULL DEFAULT '',
+                comprador_email TEXT NOT NULL DEFAULT '',
+                valor REAL NOT NULL DEFAULT 0,
+                comissao REAL NOT NULL DEFAULT 0,
+                gclid TEXT NOT NULL DEFAULT '',
+                utm_source TEXT NOT NULL DEFAULT '',
+                utm_medium TEXT NOT NULL DEFAULT '',
+                utm_campaign TEXT NOT NULL DEFAULT '',
+                status TEXT NOT NULL DEFAULT 'aprovada',
+                conversao_status TEXT NOT NULL DEFAULT 'pendente',
+                conversao_erro TEXT NOT NULL DEFAULT '',
+                gclid_match TEXT NOT NULL DEFAULT '',
+                raw TEXT NOT NULL DEFAULT '',
+                created_at TEXT NOT NULL
+            )
+            """
+        )
+        conn.execute("CREATE INDEX IF NOT EXISTS idx_vendas_gclid ON vendas (gclid)")
+        conn.execute("CREATE INDEX IF NOT EXISTS idx_vendas_created ON vendas (created_at)")
+        conn.execute("CREATE INDEX IF NOT EXISTS idx_visitas_gclid ON visitas (gclid)")
         columns = [row["name"] for row in conn.execute("PRAGMA table_info(produtos)")]
         if "analysis" not in columns:
             conn.execute("ALTER TABLE produtos ADD COLUMN analysis TEXT NOT NULL DEFAULT ''")

package/app/services/gads.py

@@ -0,0 +1,109 @@
+"""Google Ads — upload de conversões offline (click conversions via GCLID).
+
+Implementação enxuta via REST (httpx), sem SDK pesado:
+1. refresh_token -> access_token (OAuth2)
+2. POST /{version}/customers/{customer_id}:uploadClickConversions
+
+Best-effort: a versão da API é configurável (settings.api_keys['google-ads'].api_version,
+default v22) e erros da API são devolvidos com attribution clara.
+"""
+import time
+
+import httpx
+
+from .llm import LLMError
+from .store import get_settings
+
+DEFAULT_API_VERSION = "v22"
+TOKEN_URL = "https://oauth2.googleapis.com/token"
+ADS_BASE = "https://googleads.googleapis.com"
+
+
+def _google_ads_config() -> dict:
+    keys = (get_settings().get("api_keys") or {}).get("google-ads") or {}
+    return {
+        "developer_token": (keys.get("developer_token") or "").strip(),
+        "client_id": (keys.get("client_id") or "").strip(),
+        "client_secret": (keys.get("client_secret") or "").strip(),
+        "refresh_token": (keys.get("refresh_token") or "").strip(),
+        "customer_id": (keys.get("customer_id") or "").strip().replace("-", ""),
+        "conversion_action": (keys.get("conversion_action") or "").strip(),
+        "api_version": (keys.get("api_version") or "").strip() or DEFAULT_API_VERSION,
+    }
+
+
+def _access_token(client_id: str, client_secret: str, refresh_token: str) -> str:
+    try:
+        response = httpx.post(
+            TOKEN_URL,
+            data={
+                "client_id": client_id,
+                "client_secret": client_secret,
+                "refresh_token": refresh_token,
+                "grant_type": "refresh_token",
+            },
+            timeout=30.0,
+        )
+    except httpx.HTTPError as exc:
+        raise LLMError(f"Falha de conexão com o OAuth do Google: {exc}", provider="google-ads", transient=True) from exc
+    if response.status_code != 200:
+        raise LLMError(
+            f"Google OAuth rejeitou as credenciais ({response.status_code}): {response.text[:200]} — confira client_id/client_secret/refresh_token em Chaves de API.",
+            provider="google-ads",
+        )
+    return (response.json() or {}).get("access_token", "")
+
+
+def upload_conversao(gclid: str, valor: float, ocorrido_em: str | None = None, currency: str = "BRL") -> dict:
+    """Envia uma conversão offline (GCLID) ao Google Ads. Retorna dict de resultado."""
+    config = _google_ads_config()
+    missing = [field for field in ("developer_token", "client_id", "client_secret", "refresh_token", "customer_id", "conversion_action") if not config[field]]
+    if missing:
+        raise LLMError(
+            "Conversões GCLID requerem Google Ads configurado em Chaves de API: " + ", ".join(missing) + ".",
+            provider="google-ads",
+        )
+    if not gclid:
+        raise LLMError("Venda sem GCLID — não é possível enviar conversão offline.", provider="google-ads")
+
+    try:
+        access_token = _access_token(config["client_id"], config["client_secret"], config["refresh_token"])
+    except LLMError:
+        raise
+    if not access_token:
+        raise LLMError("OAuth do Google não devolveu access_token.", provider="google-ads")
+
+    ocorrido_em = ocorrido_em or time.strftime("%Y-%m-%d %H:%M:%S%z")
+    if "%z" in ocorrido_em:
+        # Formato esperado pelo Google Ads: yyyy-mm-dd hh:mm:ss+|-hh:mm
+        ocorrido_em = ocorrido_em.replace("+0000", "+00:00")
+        if len(ocorrido_em) >= 5 and ocorrido_em[-5] in "+-":
+            ocorrido_em = ocorrido_em[:-2] + ":" + ocorrido_em[-2:]
+    url = f"{ADS_BASE}/{config['api_version']}/customers/{config['customer_id']}:uploadClickConversions"
+    body = {
+        "conversions": [
+            {
+                "gclid": gclid,
+                "conversionAction": config["conversion_action"],
+                "conversionDateTime": ocorrido_em,
+                "conversionValue": valor,
+                "currencyCode": currency,
+            }
+        ],
+        "partialFailure": True,
+    }
+    headers = {
+        "Authorization": f"Bearer {access_token}",
+        "developer-token": config["developer_token"],
+        "Content-Type": "application/json",
+    }
+    try:
+        response = httpx.post(url, headers=headers, json=body, timeout=60.0)
+    except httpx.HTTPError as exc:
+        raise LLMError(f"Falha de conexão com a Google Ads API: {exc}", provider="google-ads", transient=True) from exc
+    if response.status_code == 200:
+        return {"ok": True, "resultado": response.json()}
+    raise LLMError(
+        f"Google Ads API respondeu {response.status_code}: {response.text[:300]} (API {config['api_version']}).",
+        provider="google-ads",
+    )