@danhachuel/prodmaker 0.1.8 → 0.1.10

package/app/services/campaigns.py

@@ -0,0 +1,171 @@
+"""AdsCreator — construtor de planos de campanha (defaults do seed + produto vinculado)."""
+import json
+from pathlib import Path
+
+from .database import get_db, now_str, row_to_dict
+from .llm import LLMError
+
+SEED_DIR = Path(__file__).resolve().parent.parent.parent / "seed"
+PLATAFORMAS = ("google", "meta", "tiktok")
+
+
+def _defaults(plataforma: str) -> dict:
+    aliases = {"google": "google", "meta": "meta", "tiktok": "tiktok"}
+    path = SEED_DIR / "campaign-defaults" / f"{aliases[plataforma]}.json"
+    if path.exists():
+        return json.loads(path.read_text(encoding="utf-8"))
+    return {}
+
+
+def construir(produto: dict, plataforma: str, form: dict) -> dict:
+    """Monta o plano da campanha com defaults do seed + dados do produto."""
+    if plataforma not in PLATAFORMAS:
+        raise LLMError(f"Plataforma inválida: {plataforma}. Use: google, meta, tiktok.")
+    comissao = float(produto.get("comissao") or 0)
+    preco = float(produto.get("preco") or 0)
+    receita = comissao or preco * 0.5
+    defaults = _defaults(plataforma)
+
+    if plataforma == "google":
+        cpa_alvo = round(receita * 0.7, 2) if receita else 120.0
+        orcamento = float(form.get("orcamento_diario") or 110)
+        plano = {
+            "rede": "Pesquisa (Search)",
+            "objetivo": "Vendas — conversões",
+            "lance": f"Manual CPC com lance = CPA alvo (R$ {cpa_alvo}) — troque para CPA automático quando a conversão estiver ativa",
+            "cpa_alvo": cpa_alvo,
+            "orcamento_diario": orcamento,
+            "localizacao": "Presença (apenas): Estados Unidos, Canadá, Austrália, Reino Unido",
+            "idiomas": "Inglês e Francês",
+            "correspondencia": "frase",
+            "anuncio": defaults.get("anuncio", {}),
+        }
+    elif plataforma == "meta":
+        ticket = preco or (receita / 0.5 if receita else 0)
+        criativos = max(5, int(form.get("quantidade_criativos") or 5))
+        orcamento = round(criativos * (ticket / 2), 2) if ticket else 300.0
+        plano = {
+            "estrutura": f"1 campanha → 1 conjunto → {criativos} criativos",
+            "objetivo": "Vendas (Conversões)",
+            "publico": "Aberto + Advantage+",
+            "orcamento_diario": orcamento,
+            "regra_budget": "criativos × metade do ticket",
+            "criativos": criativos,
+        }
+    else:
+        plano = {
+            "formato": "Vídeo vertical 9:16, 15–30s, estilo UGC",
+            "objetivo": "Conversões",
+            "publico": "Idade 18–45 (EUA/UK/CA/AU)",
+            "orcamento_diario": float(form.get("orcamento_diario") or 15),
+            "moeda": "USD",
+            "teste": "US$10–20/dia por criativo; escala US$50–100/dia no vencedor",
+        }
+
+    positivas = form.get("keywords") or []
+    negativas = form.get("negativas") or []
+    criativos = form.get("criativos") or []
+    return {
+        "plataforma": plataforma,
+        "nome": form.get("nome") or f"{produto.get('nome') or 'Produto'} — {plataforma.title()}",
+        "produto_id": produto.get("id"),
+        "cpa_alvo": float(plano.get("cpa_alvo") or 0),
+        "orcamento_diario": float(plano.get("orcamento_diario") or 0),
+        "keywords": positivas,
+        "negativas": negativas,
+        "criativos": criativos,
+        "plano": plano,
+        "manual": plataforma == "tiktok",
+    }
+
+
+def salvar(campanha: dict) -> dict:
+    timestamp = now_str()
+    with get_db() as conn:
+        cursor = conn.execute(
+            "INSERT INTO campanhas (produto_id, plataforma, nome, objetivo, cpa_alvo, orcamento_diario, keywords_json, negativas_json, criativos_json, plano_json, status, created_at, updated_at) "
+            "VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 'rascunho', ?, ?)",
+            (
+                campanha.get("produto_id"),
+                campanha["plataforma"],
+                campanha["nome"],
+                json.dumps(campanha["plano"].get("objetivo", ""), ensure_ascii=False),
+                campanha.get("cpa_alvo") or 0,
+                campanha.get("orcamento_diario") or 0,
+                json.dumps(campanha["keywords"], ensure_ascii=False),
+                json.dumps(campanha["negativas"], ensure_ascii=False),
+                json.dumps(campanha["criativos"], ensure_ascii=False),
+                json.dumps(campanha["plano"], ensure_ascii=False),
+                timestamp,
+                timestamp,
+            ),
+        )
+        row = conn.execute("SELECT * FROM campanhas WHERE id = ?", (cursor.lastrowid,)).fetchone()
+    return row_to_dict(row)
+
+
+def listar(produto_id: int | None = None) -> list[dict]:
+    query = "SELECT * FROM campanhas"
+    params: tuple = ()
+    if produto_id:
+        query += " WHERE produto_id = ?"
+        params = (produto_id,)
+    query += " ORDER BY id DESC"
+    with get_db() as conn:
+        rows = conn.execute(query, params).fetchall()
+    return [row_to_dict(row) for row in rows]
+
+
+def get(campanha_id: int) -> dict:
+    with get_db() as conn:
+        row = conn.execute("SELECT * FROM campanhas WHERE id = ?", (campanha_id,)).fetchone()
+    if not row:
+        raise LLMError("Campanha não encontrada.")
+    record = row_to_dict(row)
+    for field in ("keywords_json", "negativas_json", "criativos_json", "plano_json", "resultado_json"):
+        if record.get(field):
+            try:
+                record[field.replace("_json", "")] = json.loads(record[field])
+            except Exception:  # noqa: BLE001
+                record[field.replace("_json", "")] = record[field]
+    return record
+
+
+def remover(campanha_id: int) -> None:
+    with get_db() as conn:
+        cursor = conn.execute("DELETE FROM campanhas WHERE id = ?", (campanha_id,))
+        if cursor.rowcount == 0:
+            raise LLMError("Campanha não encontrada.")
+
+
+def marcar_publicada(campanha_id: int, resultado: dict, status: str = "publicada", erro: str = "") -> dict:
+    with get_db() as conn:
+        conn.execute(
+            "UPDATE campanhas SET status = ?, resultado_json = ?, erro = ?, updated_at = ? WHERE id = ?",
+            (status, json.dumps(resultado, ensure_ascii=False), erro[:2000], now_str(), campanha_id),
+        )
+    if status == "publicada":
+        from .notify import notify_event
+
+        campanha = get(campanha_id)
+        notify_event("campanha_publicada", f"Campanha publicada ({campanha['plataforma']})", f"{campanha['nome']} — criada PAUSADA para revisão.")
+    return get(campanha_id)
+
+
+def atualizar(campanha_id: int, campanha: dict) -> dict:
+    with get_db() as conn:
+        conn.execute(
+            "UPDATE campanhas SET nome = ?, cpa_alvo = ?, orcamento_diario = ?, keywords_json = ?, negativas_json = ?, criativos_json = ?, plano_json = ?, updated_at = ? WHERE id = ?",
+            (
+                campanha["nome"],
+                campanha.get("cpa_alvo") or 0,
+                campanha.get("orcamento_diario") or 0,
+                json.dumps(campanha["keywords"], ensure_ascii=False),
+                json.dumps(campanha["negativas"], ensure_ascii=False),
+                json.dumps(campanha["criativos"], ensure_ascii=False),
+                json.dumps(campanha["plano"], ensure_ascii=False),
+                now_str(),
+                campanha_id,
+            ),
+        )
+    return get(campanha_id)

package/app/services/database.py

@@ -124,9 +124,72 @@ def ensure_db() -> None:
         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)")
+        conn.execute(
+            """
+            CREATE TABLE IF NOT EXISTS palavras (
+                id INTEGER PRIMARY KEY AUTOINCREMENT,
+                produto_id INTEGER,
+                produto_nome TEXT NOT NULL DEFAULT '',
+                tipo TEXT NOT NULL DEFAULT 'positiva',
+                texto TEXT NOT NULL,
+                correspondencia TEXT NOT NULL DEFAULT 'frase',
+                origem TEXT NOT NULL DEFAULT 'ia',
+                created_at TEXT NOT NULL
+            )
+            """
+        )
+        conn.execute(
+            """
+            CREATE TABLE IF NOT EXISTS campanhas (
+                id INTEGER PRIMARY KEY AUTOINCREMENT,
+                produto_id INTEGER,
+                plataforma TEXT NOT NULL DEFAULT 'google',
+                nome TEXT NOT NULL,
+                objetivo TEXT NOT NULL DEFAULT '',
+                cpa_alvo REAL NOT NULL DEFAULT 0,
+                orcamento_diario REAL NOT NULL DEFAULT 0,
+                keywords_json TEXT NOT NULL DEFAULT '[]',
+                negativas_json TEXT NOT NULL DEFAULT '[]',
+                criativos_json TEXT NOT NULL DEFAULT '[]',
+                plano_json TEXT NOT NULL DEFAULT '',
+                status TEXT NOT NULL DEFAULT 'rascunho',
+                resultado_json TEXT NOT NULL DEFAULT '',
+                erro TEXT NOT NULL DEFAULT '',
+                created_at TEXT NOT NULL,
+                updated_at TEXT NOT NULL
+            )
+            """
+        )
         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 ''")
+        conn.execute(
+            """
+            CREATE TABLE IF NOT EXISTS lancamentos (
+                id INTEGER PRIMARY KEY AUTOINCREMENT,
+                produto_id INTEGER,
+                etapa_atual INTEGER NOT NULL DEFAULT 1,
+                status TEXT NOT NULL DEFAULT 'em_andamento',
+                dados_json TEXT NOT NULL DEFAULT '{}',
+                created_at TEXT NOT NULL,
+                updated_at TEXT NOT NULL
+            )
+            """
+        )
+        conn.execute(
+            """
+            CREATE TABLE IF NOT EXISTS notificacoes (
+                id INTEGER PRIMARY KEY AUTOINCREMENT,
+                event TEXT NOT NULL DEFAULT '',
+                titulo TEXT NOT NULL DEFAULT '',
+                mensagem TEXT NOT NULL DEFAULT '',
+                canal TEXT NOT NULL DEFAULT '',
+                status TEXT NOT NULL DEFAULT 'pendente',
+                erro TEXT NOT NULL DEFAULT '',
+                created_at TEXT NOT NULL
+            )
+            """
+        )
 
 
 def now_str() -> str:

package/app/services/lancamentos.py

@@ -0,0 +1,148 @@
+"""AdsBot — Lançamento Assistido: wizard persistido + Relatório de Lançamento."""
+import json
+from pathlib import Path
+
+from .database import get_db, now_str, row_to_dict
+from .llm import LLMError
+
+SEED_DIR = Path(__file__).resolve().parent.parent.parent / "seed"
+ETAPAS = [
+    {"numero": 1, "nome": "Produto", "emoji": "📦", "rota": "/"},
+    {"numero": 2, "nome": "Página", "emoji": "🛡️", "rota": "/adspages"},
+    {"numero": 3, "nome": "Publicar", "emoji": "🌐", "rota": "/hosting/paginas"},
+    {"numero": 4, "nome": "Campanhas", "emoji": "🎯", "rota": "/adscreator"},
+    {"numero": 5, "nome": "Tracking", "emoji": "🔄", "rota": "/tracking/visitas"},
+    {"numero": 6, "nome": "Conclusão", "emoji": "✅", "rota": "/adsbot"},
+]
+
+
+def _decode(record: dict) -> dict:
+    try:
+        record["dados"] = json.loads(record.get("dados_json") or "{}")
+    except Exception:  # noqa: BLE001
+        record["dados"] = {}
+    return record
+
+
+def _get_row(lancamento_id: int) -> dict:
+    with get_db() as conn:
+        row = conn.execute("SELECT * FROM lancamentos WHERE id = ?", (lancamento_id,)).fetchone()
+    if not row:
+        raise LLMError("Lançamento não encontrado.")
+    return row_to_dict(row)
+
+
+def atual() -> dict | None:
+    with get_db() as conn:
+        row = conn.execute("SELECT * FROM lancamentos WHERE status = 'em_andamento' ORDER BY id DESC LIMIT 1").fetchone()
+    return _decode(row_to_dict(row)) if row else None
+
+
+def listar() -> list[dict]:
+    with get_db() as conn:
+        rows = conn.execute("SELECT * FROM lancamentos ORDER BY id DESC").fetchall()
+    return [_decode(row_to_dict(row)) for row in rows]
+
+
+def iniciar(produto_id: int | None = None) -> dict:
+    existing = atual()
+    if existing:
+        if produto_id and not existing.get("produto_id"):
+            return definir_produto(existing["id"], produto_id)
+        return existing
+    timestamp = now_str()
+    with get_db() as conn:
+        cursor = conn.execute(
+            "INSERT INTO lancamentos (produto_id, etapa_atual, status, dados_json, created_at, updated_at) VALUES (?, 1, 'em_andamento', '{}', ?, ?)",
+            (produto_id, timestamp, timestamp),
+        )
+        row = conn.execute("SELECT * FROM lancamentos WHERE id = ?", (cursor.lastrowid,)).fetchone()
+    return _decode(row_to_dict(row))
+
+
+def definir_produto(lancamento_id: int, produto_id: int) -> dict:
+    with get_db() as conn:
+        conn.execute("UPDATE lancamentos SET produto_id = ?, updated_at = ? WHERE id = ?", (produto_id, now_str(), lancamento_id))
+    return _get_row(lancamento_id)
+
+
+def salvar_etapa(lancamento_id: int, etapa: int, dados: dict) -> dict:
+    if not 1 <= etapa <= len(ETAPAS):
+        raise LLMError(f"Etapa inválida (1–{len(ETAPAS)}).")
+    with get_db() as conn:
+        row = conn.execute("SELECT * FROM lancamentos WHERE id = ?", (lancamento_id,)).fetchone()
+        if not row:
+            raise LLMError("Lançamento não encontrado.")
+        merged = {}
+        try:
+            merged = json.loads(row["dados_json"] or "{}")
+        except Exception:  # noqa: BLE001
+            merged = {}
+        merged.update(dados or {})
+        conn.execute(
+            "UPDATE lancamentos SET etapa_atual = ?, dados_json = ?, updated_at = ? WHERE id = ?",
+            (max(etapa, row["etapa_atual"] if row["status"] == "concluido" else 0), json.dumps(merged, ensure_ascii=False), now_str(), lancamento_id),
+        )
+    return _get_row(lancamento_id)
+
+
+def concluir(lancamento_id: int) -> dict:
+    with get_db() as conn:
+        conn.execute("UPDATE lancamentos SET status = 'concluido', etapa_atual = ?, updated_at = ? WHERE id = ?", (len(ETAPAS), now_str(), lancamento_id))
+    return relatorio(lancamento_id)
+
+
+def relatorio(lancamento_id: int) -> dict:
+    record = _get_row(lancamento_id)
+    dados = json.loads(record.get("dados_json") or "{}")
+    produto_id = record.get("produto_id") or dados.get("produto_id")
+    produto = None
+    analysis = None
+    paginas = []
+    campanhas = []
+    if produto_id:
+        with get_db() as conn:
+            produto_row = conn.execute("SELECT * FROM produtos WHERE id = ?", (produto_id,)).fetchone()
+            if produto_row:
+                produto = row_to_dict(produto_row)
+        if produto and produto.get("analysis"):
+            try:
+                analysis = json.loads(produto["analysis"])
+            except Exception:  # noqa: BLE001
+                analysis = None
+        with get_db() as conn:
+            paginas = [row_to_dict(r) for r in conn.execute("SELECT * FROM paginas WHERE produto_id = ? ORDER BY id DESC", (produto_id,)).fetchall()]
+            campanhas = [row_to_dict(r) for r in conn.execute("SELECT * FROM campanhas WHERE produto_id = ? ORDER BY id DESC", (produto_id,)).fetchall()]
+    checklist_path = SEED_DIR / "checklists" / "lancamento.md"
+    checklist = ""
+    if checklist_path.exists():
+        checklist = checklist_path.read_text(encoding="utf-8")
+    return {
+        "lancamento": record,
+        "produto": produto,
+        "analysis": analysis,
+        "paginas": [
+            {"id": p["id"], "titulo": p["titulo"], "tipo": p["tipo"], "status": p["status"], "published_url": p["published_url"]}
+            for p in paginas
+        ],
+        "campanhas": [
+            {"id": c["id"], "nome": c["nome"], "plataforma": c["plataforma"], "status": c["status"], "cpa_alvo": c["cpa_alvo"], "orcamento_diario": c["orcamento_diario"]}
+            for c in campanhas
+        ],
+        "checklist": checklist,
+        "etapas": ETAPAS,
+    }
+
+
+def progresso(record: dict) -> dict:
+    etapa = record.get("etapa_atual") or 1
+    total = len(ETAPAS)
+    concluido = record.get("status") == "concluido"
+    percentual = 100 if concluido else round((etapa - 1) / total * 100)
+    return {
+        "etapa": etapa,
+        "total": total,
+        "percentual": percentual,
+        "faltam": 0 if concluido else total - etapa + 1,
+        "status": record.get("status"),
+    }

package/app/services/notify.py

@@ -0,0 +1,127 @@
+"""AdsNotify — notificações push (apprise) + histórico local.
+
+- Canais: URLs apprise configuradas em settings.notifications.targets. Se houver Telegram
+  configurado em Chaves de API, o destino t://TOKEN/CHATID entra automaticamente.
+- Eventos com toggle em settings.notifications.eventos (default: desligados).
+- Falha de envio NUNCA quebra o fluxo — apenas registra no histórico.
+"""
+import json
+import time
+
+from .database import get_db, now_str, row_to_dict
+from .llm import LLMError
+from .store import get_settings
+
+EVENTOS = {
+    "venda_recebida": "Venda recebida",
+    "campanha_publicada": "Campanha publicada",
+    "pagina_publicada": "Página publicada",
+    "infoproduto_gerado": "Infoproduto gerado",
+}
+
+
+def _telegram_target() -> str | None:
+    keys = (get_settings().get("api_keys") or {}).get("telegram") or {}
+    token = (keys.get("bot_token") or "").strip()
+    chat_id = (keys.get("chat_id") or "").strip()
+    if token and chat_id:
+        return f"tgram://{token}/{chat_id}"
+    return None
+
+
+def listar_config() -> dict:
+    settings = get_settings()
+    notifications = settings.get("notifications") or {}
+    return {
+        "eventos": {key: bool((notifications.get("eventos") or {}).get(key, False)) for key in EVENTOS},
+        "targets": notifications.get("targets") or [],
+        "eventos_disponiveis": EVENTOS,
+        "canal_telegram": bool(_telegram_target()),
+    }
+
+
+def salvar_config(eventos: dict, targets: list) -> dict:
+    settings = get_settings()
+    current = settings.get("notifications") or {}
+    merged_eventos = {key: bool((current.get("eventos") or {}).get(key, False)) for key in EVENTOS}
+    merged_eventos.update({key: bool(value) for key, value in (eventos or {}).items() if key in EVENTOS})
+    settings["notifications"] = {"eventos": merged_eventos, "targets": [str(item).strip() for item in (targets or []) if str(item).strip()]}
+    from .store import save_settings
+
+    save_settings(settings)
+    return listar_config()
+
+
+def historico(limit: int = 50) -> list[dict]:
+    with get_db() as conn:
+        rows = conn.execute("SELECT * FROM notificacoes ORDER BY id DESC LIMIT ?", (limit,)).fetchall()
+    return [row_to_dict(row) for row in rows]
+
+
+def _registrar(event: str, titulo: str, mensagem: str, canal: str, status: str, erro: str = "") -> None:
+    with get_db() as conn:
+        conn.execute(
+            "INSERT INTO notificacoes (event, titulo, mensagem, canal, status, erro, created_at) VALUES (?, ?, ?, ?, ?, ?, ?)",
+            (event, titulo, mensagem, canal, status, erro[:2000], now_str()),
+        )
+
+
+def _alvos() -> list[str]:
+    settings = get_settings()
+    targets = list((settings.get("notifications") or {}).get("targets") or [])
+    telegram = _telegram_target()
+    if telegram and telegram not in targets:
+        targets.insert(0, telegram)
+    return [item for item in targets if item.strip()]
+
+
+def _is_enabled(event: str) -> bool:
+    settings = get_settings()
+    return bool(((settings.get("notifications") or {}).get("eventos") or {}).get(event, False))
+
+
+def enviar(event: str, titulo: str, mensagem: str, forcar: bool = False) -> dict:
+    """Envia uma notificação pelos canais configurados (best-effort)."""
+    if not forcar and not _is_enabled(event):
+        return {"enviado": False, "motivo": "evento desligado"}
+    alvos = _alvos()
+    if not alvos:
+        erro = "Nenhum canal configurado (settings.notifications.targets ou Telegram em Chaves de API)."
+        _registrar(event, titulo, mensagem, "", "erro", erro)
+        if forcar:
+            raise LLMError(erro)
+        return {"enviado": False, "motivo": erro}
+    try:
+        import apprise
+    except ImportError as exc:
+        _registrar(event, titulo, mensagem, ",".join(alvos), "erro", f"apprise ausente ({exc.name}) — rode 'prodmaker install'.")
+        return {"enviado": False, "motivo": "apprise não instalado"}
+    apobj = apprise.Apprise()
+    enviados = []
+    erros = []
+    for alvo in alvos:
+        if apobj.add(alvo):
+            enviados.append(alvo)
+        else:
+            erros.append(f"canal inválido: {alvo}")
+    if not enviados:
+        erro = "; ".join(erros)
+        _registrar(event, titulo, mensagem, ",".join(alvos), "erro", erro)
+        raise LLMError(erro)
+    ok = apobj.notify(title=titulo, body=mensagem)
+    if ok:
+        _registrar(event, titulo, mensagem, ",".join(enviados), "enviada")
+        return {"enviado": True, "canais": enviados}
+    erro = "apprise não conseguiu entregar (verifique tokens/chat id)."
+    _registrar(event, titulo, mensagem, ",".join(enviados), "erro", erro)
+    raise LLMError(erro)
+
+
+def notify_event(event: str, titulo: str, mensagem: str) -> None:
+    """Hook seguro: usado pelos fluxos de venda/página/campanha/infoproduto."""
+    try:
+        enviar(event, titulo, mensagem)
+    except LLMError:
+        pass
+    except Exception:  # noqa: BLE001 — notificação nunca quebra a operação principal
+        pass