@danhachuel/prodmaker 0.1.13 → 0.1.15

package/app/services/fraude.py

@@ -0,0 +1,174 @@
+"""Anti-Fraude do AdsPixel — padrão do redis-datasets/fraud-detection:
+IP blacklisting (Redis Cuckoo Filter) + click spamming (Redis Sorted Set).
+
+- Redis é OPCIONAL: sem Redis, tudo cai em SQLite local (tabelas ips_bloqueados /
+  fraude_eventos) — bloqueio e detecção continuam funcionando.
+- O pixel NUNCA quebra a página do visitante: avaliação em falha = segue normalmente.
+"""
+import json
+import os
+import time
+
+from .database import get_db, now_str, row_to_dict
+from .llm import LLMError
+from .store import get_settings
+
+CUCKOO_KEY = "prodmaker:ip_blacklist_cf"      # Redis Cuckoo Filter (IP_BLOCKED)
+SPAM_KEY = "prodmaker:click_spamming"          # Redis Sorted Set (IP -> timestamp)
+SPAM_JANELA_SEGUNDOS = int(os.environ.get("PRODMAKER_SPAM_JANELA") or "60")
+SPAM_LIMITE = int(os.environ.get("PRODMAKER_SPAM_LIMITE") or "10")
+
+
+def _redis_url() -> str | None:
+    env = (os.environ.get("REDIS_URL") or "").strip()
+    if env:
+        return env
+    keys = (get_settings().get("api_keys") or {}).get("redis") or {}
+    return (keys.get("url") or "").strip() or None
+
+
+def _redis():
+    url = _redis_url()
+    if not url:
+        return None
+    try:
+        import redis
+
+        client = redis.Redis.from_url(url, decode_responses=True, socket_timeout=2)
+        client.ping()
+        return client
+    except Exception:
+        return None  # sem Redis: fallback SQLite
+
+
+def redis_ativo() -> bool:
+    return _redis() is not None
+
+
+# ---------------------------------------------------------------------------
+# Blacklist (Cuckoo Filter quando há Redis; tabela local sempre)
+# ---------------------------------------------------------------------------
+
+
+def _bloqueados_locais() -> dict[str, str]:
+    with get_db() as conn:
+        rows = conn.execute("SELECT ip, motivo FROM ips_bloqueados ORDER BY id DESC").fetchall()
+    return {row["ip"]: row["motivo"] for row in rows}
+
+
+def bloquear_ip(ip: str, motivo: str = "manual") -> dict:
+    ip = (ip or "").strip()
+    if not ip:
+        raise LLMError("Informe o IP a bloquear.")
+    client = _redis()
+    if client:
+        try:
+            client.execute_command("CF.ADDR", CUCKOO_KEY, ip)
+        except Exception:
+            pass  # filtro ausente no servidor: fica só local
+    with get_db() as conn:
+        existe = conn.execute("SELECT id FROM ips_bloqueados WHERE ip = ?", (ip,)).fetchone()
+        if not existe:
+            conn.execute(
+                "INSERT INTO ips_bloqueados (ip, motivo, origem, created_at) VALUES (?, ?, ?, ?)",
+                (ip, motivo, "redis" if client else "sqlite", now_str()),
+            )
+    return {"ok": True, "ip": ip, "engine": "redis" if client else "sqlite"}
+
+
+def desbloquear_ip(ip: str) -> None:
+    with get_db() as conn:
+        cursor = conn.execute("DELETE FROM ips_bloqueados WHERE ip = ?", (ip.strip(),))
+        if cursor.rowcount == 0:
+            raise LLMError("IP não encontrado na lista de bloqueio.")
+
+
+def ip_bloqueado(ip: str) -> bool:
+    if not ip:
+        return False
+    client = _redis()
+    if client:
+        try:
+            resposta = client.execute_command("CF.EXISTS", CUCKOO_KEY, ip)
+            if isinstance(resposta, list):
+                resposta = resposta[0] if resposta else 0
+            if int(resposta):
+                return True
+        except Exception:
+            pass  # redis sem o módulo RedisBloom: cai no local
+    return (ip or "").strip() in _bloqueados_locais()
+
+
+# ---------------------------------------------------------------------------
+# Click spamming (Sorted Set quando há Redis)
+# ---------------------------------------------------------------------------
+
+
+def registrar_clique(ip: str, page: str = "") -> dict:
+    """Registra um clique e devolve {spam: bool, cliques_janela: N}."""
+    ip = (ip or "").strip()
+    if not ip:
+        return {"spam": False, "cliques_janela": 0, "bloqueado": False}
+    agora = time.time()
+    cliques = 0
+    client = _redis()
+    if client:
+        try:
+            member = f"{int(agora * 1000)}:{ip}"
+            pipeline = client.pipeline()
+            pipeline.execute_command("ZADD", SPAM_KEY, agora, member)
+            pipeline.execute_command("ZREMRANGEBYSCORE", SPAM_KEY, 0, agora - SPAM_JANELA_SEGUNDOS)
+            pipeline.execute_command(
+                "ZCOUNT", SPAM_KEY, (int((agora - SPAM_JANELA_SEGUNDOS) * 1000)), int(agora * 1000)
+            )
+            cliques = int(pipeline.execute()[-1])
+        except Exception:
+            cliques = _cliques_local(ip, agora, page)
+    else:
+        cliques = _cliques_local(ip, agora, page)
+    spam = cliques >= SPAM_LIMITE
+    return {"spam": spam, "cliques_janela": cliques, "bloqueado": ip_bloqueado(ip)}
+
+
+def _cliques_local(ip: str, agora: float, page: str = "") -> int:
+    with get_db() as conn:
+        conn.execute("DELETE FROM fraude_eventos WHERE created_epoch < ?", (agora - SPAM_JANELA_SEGUNDOS * 2,))
+        conn.execute("INSERT INTO fraude_eventos (ip, page, created_epoch, created_at) VALUES (?, ?, ?, ?)", (ip, page or "", agora, now_str()))
+        row = conn.execute(
+            "SELECT COUNT(*) AS n FROM fraude_eventos WHERE ip = ? AND created_epoch > ?",
+            (ip, agora - SPAM_JANELA_SEGUNDOS),
+        ).fetchone()
+    return int(row["n"])
+
+
+# ---------------------------------------------------------------------------
+# Painel / API
+# ---------------------------------------------------------------------------
+
+
+def resumo() -> dict:
+    bloqueados = _bloqueados_locais()
+    spam_24h = 0
+    with get_db() as conn:
+        row = conn.execute(
+            "SELECT COUNT(*) AS n FROM fraude_eventos WHERE created_at >= datetime('now', '-1 day') GROUP BY ip HAVING COUNT(*) >= ?",
+            (SPAM_LIMITE,),
+        ).fetchone()
+        spam_24h = row["n"] if row else 0
+    return {
+        "redis_ativo": redis_ativo(),
+        "ips_bloqueados": [
+            {"ip": ip, "motivo": motivo} for ip, motivo in bloqueados.items()
+        ],
+        "total_bloqueados": len(bloqueados),
+        "spam_ultimas_24h": spam_24h,
+        "janela_segundos": SPAM_JANELA_SEGUNDOS,
+        "limite_cliques": SPAM_LIMITE,
+    }
+
+
+def avaliar_visita(ip: str) -> dict:
+    """Chamado pelo /track: decide se a visita entra no tracking."""
+    if ip_bloqueado(ip):
+        return {"bloqueado": True, "motivo": _bloqueados_locais().get((ip or "").strip(), "blacklist")}
+    return {"bloqueado": False}

package/app/services/publish_ads.py

@@ -1,6 +1,7 @@
-"""Engines de publicação de campanhas — Google Ads (REST mutates) e Meta Ads (Marketing API).
+"""Engines de publicação de campanhas — Google Ads (REST mutates), Meta Ads
+(Marketing API) e TikTok Ads (Marketing API OAuth).
 
-Best-effort com erros atribuídos por etapa. TikTok permanece manual (guia no plano).
+Best-effort com erros atribuídos por etapa. Tudo é criado PAUSADO para revisão.
 """
 import httpx
 

package/app/services/publish_tiktok.py

@@ -0,0 +1,155 @@
+"""TikTok Ads — publicação automática via Marketing API (OAuth + campaign/adgroup).
+
+Fluxo: auth_code (do portal TikTok) -> access_token (24h) -> refresh_token ->
+campanha PAUSADA -> grupo de anúncios. O criativo (vídeo/imagem) exige upload de
+arquivo local: sem vídeo informado, a campanha e o grupo são criados e o passo
+final (anúncio) fica como instrução honesta — nenhum hack é inventado.
+"""
+import time
+
+import httpx
+
+from .llm import LLMError
+from .store import get_settings, save_settings
+
+TIKTOK_API = "https://business-api.tiktok.com/open_api/v1.3"
+
+
+def _keys() -> dict:
+    keys = (get_settings().get("api_keys") or {}).get("tiktok") or {}
+    return {
+        "app_id": (keys.get("app_id") or "").strip(),
+        "app_secret": (keys.get("app_secret") or "").strip(),
+        "auth_code": (keys.get("auth_code") or "").strip(),
+        "access_token": (keys.get("access_token") or "").strip(),
+        "refresh_token": (keys.get("refresh_token") or "").strip(),
+        "advertiser_id": (keys.get("advertiser_id") or "").strip(),
+    }
+
+
+def _check(required: list[str]) -> None:
+    config = _keys()
+    missing = [field for field in required if not config[field]]
+    if missing:
+        raise LLMError(
+            "TikTok Ads requer em Chaves de API: " + ", ".join(missing) + ".",
+            provider="tiktok",
+        )
+
+
+def trocar_auth_code() -> dict:
+    """Troca o auth_code (portal TikTok) por access_token + refresh_token."""
+    config = _keys()
+    _check(["app_id", "app_secret", "auth_code"])
+    try:
+        response = httpx.post(
+            f"{TIKTOK_API}/oauth2/access_token/",
+            json={"app_id": config["app_id"], "secret": config["app_secret"], "auth_code": config["auth_code"]},
+            timeout=30.0,
+        )
+    except httpx.HTTPError as exc:
+        raise LLMError(f"Falha de conexão com o TikTok: {exc}", provider="tiktok", transient=True) from exc
+    payload = response.json() or {}
+    if payload.get("code") != 0:
+        raise LLMError(
+            f"TikTok rejeitou o auth_code ({payload.get('code')}): {payload.get('message')} — gere um novo código no portal.",
+            provider="tiktok",
+        )
+    data = payload.get("data") or {}
+    access_token = data.get("access_token")
+    refresh_token = data.get("refresh_token")
+    advertiser_ids = data.get("advertiser_ids") or []
+    if not access_token:
+        raise LLMError("TikTok não devolveu access_token.", provider="tiktok")
+
+    settings = get_settings()
+    tiktok = settings.setdefault("api_keys", {}).setdefault("tiktok", {})
+    tiktok["access_token"] = access_token
+    tiktok["refresh_token"] = refresh_token
+    tiktok["connected_at"] = time.strftime("%Y-%m-%dT%H:%M:%S")
+    if advertiser_ids and not (tiktok.get("advertiser_id") or "").strip():
+        tiktok["advertiser_id"] = str(advertiser_ids[0])
+    save_settings(settings)
+    return {
+        "ok": True,
+        "connected_at": tiktok["connected_at"],
+        "advertiser_ids": advertiser_ids,
+        "advertiser_id": tiktok.get("advertiser_id"),
+    }
+
+
+def _post(path: str, body: dict, token: str) -> dict:
+    try:
+        response = httpx.post(
+            f"{TIKTOK_API}{path}",
+            headers={"Access-Token": token, "Content-Type": "application/json"},
+            json=body,
+            timeout=60.0,
+        )
+    except httpx.HTTPError as exc:
+        raise LLMError(f"Falha de conexão com o TikTok: {exc}", provider="tiktok", transient=True) from exc
+    payload = response.json() or {}
+    if payload.get("code") != 0:
+        raise LLMError(
+            f"TikTok API ({path}) {payload.get('code')}: {payload.get('message')}",
+            provider="tiktok",
+        )
+    return payload.get("data") or {}
+
+
+def publicar_campanha(campanha: dict) -> dict:
+    """Cria campanha (PAUSADA) + grupo de anúncios. Criativo final = instrução honesta."""
+    config = _keys()
+    _check(["app_id", "app_secret", "advertiser_id", "access_token"])
+    plano = campanha.get("plano") or {}
+    nome = campanha["nome"]
+    orcamento_dia = float(campanha.get("orcamento_diario") or 0)
+    if orcamento_dia <= 0:
+        orcamento_dia = 15.0
+    budget_cents = int(orcamento_dia * 100)
+
+    etapas = []
+    campaign = _post(
+        "/campaign/create/",
+        {
+            "advertiser_id": config["advertiser_id"],
+            "campaign_name": nome,
+            "objective_type": "CONVERSIONS",
+            "budget_mode": "BUDGET_MODE_DAY",
+            "budget": budget_cents,
+            "operation_status": "DISABLE",
+        },
+        config["access_token"],
+    )
+    campaign_id = campaign.get("campaign_id")
+    etapas.append({"etapa": "campanha", "id": campaign_id, "status": "PAUSED"})
+
+    adgroup = _post(
+        "/adgroup/create/",
+        {
+            "advertiser_id": config["advertiser_id"],
+            "campaign_id": campaign_id,
+            "adgroup_name": f"{nome} — Grupo 1",
+            "placement_type": "PLACEMENT_TYPE_AUTOMATIC",
+            "budget_mode": "BUDGET_MODE_DAY",
+            "budget": budget_cents,
+            "schedule_type": "SCHEDULE_START_END",
+            "optimization_goal": "CONVERT",
+            "billing_event": "OCPM",
+            "operation_status": "DISABLE",
+        },
+        config["access_token"],
+    )
+    adgroup_id = adgroup.get("adgroup_id")
+    etapas.append({"etapa": "grupo", "id": adgroup_id, "status": "PAUSED"})
+
+    return {
+        "plataforma": "tiktok",
+        "etapas": etapas,
+        "campaign": campaign_id,
+        "adgroup": adgroup_id,
+        "observacao": (
+            "Campanha e grupo criados PAUSADOS. Passo final (anúncio): suba o vídeo vertical 9:16 "
+            "em TikTok Ads Manager ou use o upload de criativo — o ProdMaker avisa quando não há mídia informada."
+        ),
+    }