@danhachuel/prodmaker 0.1.9 → 0.1.11

package/CHANGELOG.md

@@ -3,6 +3,45 @@
 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.11 — 2026-10-30
+
+- **Parte 9 — Pinterest (orgânico), Logs unificado e FAQ/Documentação** — fecha o menu do AdsX.
+- **Pinterest funcional:** geração de 10 ideias de pins por IA (título ≤100 chars, descrição ≤500,
+  texto na imagem, sugestão de imagem), board/link por produto, estados (ideia → pronto →
+  agendado → publicado), exportação CSV (selecionados ou todos) e agendamento via py3-pinterest
+  (import preguiçoso; erros honestos quando sem credenciais/sessão manual).
+- **Logs unificado:** tabela com Operação, Estado, Data/Hora, Origem e Detalhes agregando
+  campanhas, páginas, infoprodutos, vendas, notificações e visitas — com filtros por operação,
+  estado e busca livre + cópia da linha.
+- **FAQ & Documentação:** FAQ em accordion (login/REGRA ZERO/chaves/publicação/tracking/etc.)
+  + guias de referência servidos do `seed/references` (pixel-e-tuneis.md, webhooks-de-venda.md)
+  + link para /legal (verificação de aplicação LGPD).
+- requirements.txt: + apprise, py3-pinterest (imports preguiçosos — boot preservado).
+- Nova tabela `pins`. Único módulo restante como placeholder: **Contas do Google** (OAuth
+  multi-conta — backlog da parte de contas).
+- **Conjunto AdsX completo:** Seus Produtos · AdsDashboard · AdsHosting · Infoprodutos ·
+  AdsPages · AdsWords · AdsCreator · AdsTracking (Visitas/Vendas/GCLID) · AdsBot · Pinterest ·
+  Chaves de API · Notificações · Logs · FAQ.
+
+## 0.1.10 — 2026-10-30
+
+- **Parte 8 — AdsBot (Lançamento Assistido) + Dashboard real + Notificações (adsNotify).**
+- **AdsBot:** wizard de 6 etapas (Produto → Página → Publicar → Campanhas → Tracking →
+  Conclusão) com progresso salvo no banco e retomável; marcação de etapas concluídas;
+  **Relatório de Lançamento** (produto + resumo da análise IA, páginas vinculadas com URLs
+  públicas, campanhas com CPA/orçamento e o checklist final do seed).
+- **Dashboard com dados reais:** conversões, receita, comissão, visitas, produtos, páginas,
+  campanhas e infoprodutos; banner do lançamento em andamento ("faltam X passos" — efeito
+  meta); últimas vendas e últimas páginas. ROAS explicitamente ausente até haver registro
+  de investimento (nunca inventado).
+- **Notificações (adsNotify):** toggles por evento (venda recebida, campanha publicada,
+  página publicada, infoproduto gerado), canais apprise por URL (Telegram entra
+  automaticamente quando Bot Token + Chat ID estão em Chaves de API), teste de envio e
+  histórico local com status/erro. Hooks disparados nos fluxos reais — falha de envio
+  nunca quebra a operação principal.
+- Novas tabelas: `lancamentos`, `notificacoes`. Novos endpoints: `/api/lancamentos/*`,
+  `/api/notificacoes/*`, `/api/dashboard`.
+
 ## 0.1.09 — 2026-10-30
 
 - **Parte 7 — AdsWords & AdsCreator (palavras-chave e campanhas).**

package/app/api/dashboard.py

@@ -0,0 +1,67 @@
+"""Dashboard — agregação de dados reais de todos os módulos."""
+from fastapi import APIRouter
+
+from ..services.database import get_db
+
+router = APIRouter(prefix="/api/dashboard", tags=["dashboard"])
+
+
+@router.get("")
+def dashboard():
+    with get_db() as conn:
+        produtos = {
+            "total": conn.execute("SELECT COUNT(*) AS n FROM produtos").fetchone()["n"],
+            "aprovados": conn.execute("SELECT COUNT(*) AS n FROM produtos WHERE status = 'aprovado'").fetchone()["n"],
+            "em_analise": conn.execute("SELECT COUNT(*) AS n FROM produtos WHERE status = 'em_analise'").fetchone()["n"],
+        }
+        paginas = {
+            "total": conn.execute("SELECT COUNT(*) AS n FROM paginas").fetchone()["n"],
+            "publicadas": conn.execute("SELECT COUNT(*) AS n FROM paginas WHERE status = 'publicada'").fetchone()["n"],
+            "rascunho": conn.execute("SELECT COUNT(*) AS n FROM paginas WHERE status != 'publicada'").fetchone()["n"],
+        }
+        campanhas = {
+            "total": conn.execute("SELECT COUNT(*) AS n FROM campanhas").fetchone()["n"],
+            "publicadas": conn.execute("SELECT COUNT(*) AS n FROM campanhas WHERE status = 'publicada'").fetchone()["n"],
+            "rascunho": conn.execute("SELECT COUNT(*) AS n FROM campanhas WHERE status = 'rascunho'").fetchone()["n"],
+            "erro": conn.execute("SELECT COUNT(*) AS n FROM campanhas WHERE status = 'erro'").fetchone()["n"],
+        }
+        vendas_row = conn.execute(
+            "SELECT COUNT(*) AS n, COALESCE(SUM(valor),0) AS receita, COALESCE(SUM(comissao),0) AS comissao FROM vendas WHERE status = 'aprovada'"
+        ).fetchone()
+        infoprodutos = {"total": conn.execute("SELECT COUNT(*) AS n FROM infoprodutos").fetchone()["n"]}
+        tracking = {
+            "visitas": conn.execute("SELECT COUNT(*) AS n FROM visitas WHERE event = 'pageview'").fetchone()["n"],
+            "cliques": conn.execute("SELECT COUNT(*) AS n FROM visitas WHERE event = 'cta_click'").fetchone()["n"],
+            "conversoes_pendentes": conn.execute(
+                "SELECT COUNT(*) AS n FROM vendas WHERE status = 'aprovada' AND gclid != '' AND conversao_status != 'enviada'"
+            ).fetchone()["n"],
+        }
+        ultimas_vendas = [
+            {key: row[key] for key in row.keys()}
+            for row in conn.execute("SELECT id, produto_nome, valor, fonte, status, created_at FROM vendas ORDER BY id DESC LIMIT 5")
+        ]
+        ultimas_paginas = [
+            {key: row[key] for key in row.keys()}
+            for row in conn.execute("SELECT id, titulo, tipo, status, created_at FROM paginas ORDER BY id DESC LIMIT 5")
+        ]
+
+    from ..services.lancamentos import atual, progresso
+    lancamento_atual = atual()
+    progresso_atual = progresso(lancamento_atual) if lancamento_atual else None
+
+    return {
+        "produtos": produtos,
+        "paginas": paginas,
+        "campanhas": campanhas,
+        "infoprodutos": infoprodutos,
+        "vendas": {
+            "total": vendas_row["n"],
+            "receita": round(vendas_row["receita"], 2),
+            "comissao": round(vendas_row["comissao"], 2),
+        },
+        "tracking": tracking,
+        "ultimas_vendas": ultimas_vendas,
+        "ultimas_paginas": ultimas_paginas,
+        "lancamento": lancamento_atual,
+        "progresso": progresso_atual,
+    }

package/app/api/guias.py

@@ -0,0 +1,34 @@
+"""Guias de referência (seed/references) — servidos para a página FAQ/Documentação."""
+from pathlib import Path
+
+from fastapi import APIRouter, HTTPException
+
+router = APIRouter(prefix="/api/guias", tags=["guias"])
+
+REFERENCES_DIR = Path(__file__).resolve().parent.parent.parent / "seed" / "references"
+
+
+@router.get("")
+def listar():
+    guias = []
+    if REFERENCES_DIR.exists():
+        for path in sorted(REFERENCES_DIR.glob("*.md")):
+            try:
+                titulo = ""
+                linhas = path.read_text(encoding="utf-8").splitlines()
+                if linhas and linhas[0].startswith("#"):
+                    titulo = linhas[0].lstrip("#").strip()
+                guias.append({"arquivo": path.name, "titulo": titulo or path.stem, "chars": len(path.read_text(encoding="utf-8"))})
+            except Exception:  # noqa: BLE001
+                continue
+    return guias
+
+
+@router.get("/{arquivo}")
+def ler(arquivo: str):
+    if "/" in arquivo or ".." in arquivo or not arquivo.endswith(".md"):
+        raise HTTPException(status_code=400, detail="Arquivo inválido.")
+    path = (REFERENCES_DIR / arquivo).resolve()
+    if not path.is_file() or REFERENCES_DIR.resolve() not in path.parents:
+        raise HTTPException(status_code=404, detail="Guia não encontrado.")
+    return {"arquivo": path.name, "conteudo": path.read_text(encoding="utf-8")}

package/app/api/infoprodutos.py

@@ -88,7 +88,16 @@ def create_infoproduto(body: InfoprodutoBody):
                 (provider, rel_pdf, rel_md, record_id),
             )
             row = conn.execute("SELECT * FROM infoprodutos WHERE id = ?", (record_id,)).fetchone()
-        return row_to_dict(row)
+        record = row_to_dict(row)
+
+        from ..services.notify import notify_event
+
+        notify_event(
+            "infoproduto_gerado",
+            "Infoproduto gerado",
+            f"{record['titulo']} ({record['formato']}) — {record['provider']}",
+        )
+        return record
     except (LLMError, gamma_service.GammaError, RuntimeError) as exc:
         with get_db() as conn:
             conn.execute("DELETE FROM infoprodutos WHERE id = ?", (record_id,))

package/app/api/lancamentos.py

@@ -0,0 +1,81 @@
+from fastapi import APIRouter, HTTPException
+from pydantic import BaseModel
+
+from ..services import lancamentos
+from ..services.llm import LLMError
+
+router = APIRouter(prefix="/api/lancamentos", tags=["lancamentos"])
+
+
+class IniciarBody(BaseModel):
+    produto_id: int | None = None
+
+
+class EtapaBody(BaseModel):
+    etapa: int
+    dados: dict = {}
+
+
+class ProdutoBody(BaseModel):
+    produto_id: int
+
+
+@router.get("/etapas")
+def etapas():
+    return lancamentos.ETAPAS
+
+
+@router.get("/atual")
+def lancamento_atual():
+    return lancamentos.atual()
+
+
+@router.get("")
+def listar():
+    return lancamentos.listar()
+
+
+@router.post("")
+def iniciar(body: IniciarBody):
+    return lancamentos.iniciar(body.produto_id)
+
+
+@router.post("/{lancamento_id}/etapa")
+def salvar_etapa(lancamento_id: int, body: EtapaBody):
+    try:
+        return lancamentos.salvar_etapa(lancamento_id, body.etapa, body.dados)
+    except LLMError as exc:
+        raise HTTPException(status_code=400, detail=str(exc))
+
+
+@router.post("/{lancamento_id}/produto")
+def definir_produto(lancamento_id: int, body: ProdutoBody):
+    try:
+        return lancamentos.definir_produto(lancamento_id, body.produto_id)
+    except LLMError as exc:
+        raise HTTPException(status_code=404, detail=str(exc))
+
+
+@router.get("/{lancamento_id}/relatorio")
+def relatorio(lancamento_id: int):
+    try:
+        return lancamentos.relatorio(lancamento_id)
+    except LLMError as exc:
+        raise HTTPException(status_code=404, detail=str(exc))
+
+
+@router.get("/{lancamento_id}/progresso")
+def progresso(lancamento_id: int):
+    try:
+        record = lancamentos._get_row(lancamento_id)
+    except LLMError as exc:
+        raise HTTPException(status_code=404, detail=str(exc))
+    return lancamentos.progresso(record)
+
+
+@router.post("/{lancamento_id}/concluir")
+def concluir(lancamento_id: int):
+    try:
+        return lancamentos.concluir(lancamento_id)
+    except LLMError as exc:
+        raise HTTPException(status_code=404, detail=str(exc))

package/app/api/logs.py

@@ -0,0 +1,42 @@
+"""Logs unificados — visão de operações de todos os módulos."""
+from fastapi import APIRouter
+
+from ..services.database import get_db, row_to_dict
+
+router = APIRouter(prefix="/api/logs", tags=["logs"])
+
+
+def _entry(operacao: str, estado: str, data: str, origem: str, detalhe: str) -> dict:
+    return {"operacao": operacao, "estado": estado, "data": data, "origem": origem, "detalhe": detalhe}
+
+
+@router.get("")
+def logs(limite: int = 300, operacao: str = "", estado: str = ""):
+    entries: list[dict] = []
+    with get_db() as conn:
+        for row in conn.execute("SELECT * FROM campanhas ORDER BY id DESC LIMIT ?", (limite,)).fetchall():
+            record = row_to_dict(row)
+            estado_row = record["status"]
+            entries.append(_entry("campanha", estado_row, record["updated_at"], record["plataforma"], f"{record['nome']} — CPA R$ {record['cpa_alvo']} · R$ {record['orcamento_diario']}/dia" + (f" · erro: {record['erro'][:120]}" if record["erro"] else "")))
+        for row in conn.execute("SELECT * FROM paginas ORDER BY id DESC LIMIT ?", (limite,)).fetchall():
+            record = row_to_dict(row)
+            entries.append(_entry("pagina", record["status"], record["updated_at"], record["tipo"], f"{record['titulo']}" + (f" — {record['published_url']}" if record["published_url"] else "")))
+        for row in conn.execute("SELECT * FROM infoprodutos ORDER BY id DESC LIMIT ?", (limite,)).fetchall():
+            record = row_to_dict(row)
+            entries.append(_entry("infoproduto", "gerado", record["created_at"], record["provider"] or "llm", f"{record['titulo']} ({record['modo']})"))
+        for row in conn.execute("SELECT * FROM vendas ORDER BY id DESC LIMIT ?", (limite,)).fetchall():
+            record = row_to_dict(row)
+            entries.append(_entry("venda", record["status"], record["created_at"], record["fonte"], f"{record['produto_nome'] or '#' + str(record['id'])} — valor {record['valor']} · conversao {record['conversao_status']}" + (f" · gclid {record['gclid'][:16]}" if record["gclid"] else "")))
+        for row in conn.execute("SELECT * FROM notificacoes ORDER BY id DESC LIMIT ?", (limite,)).fetchall():
+            record = row_to_dict(row)
+            entries.append(_entry("notificacao", record["status"], record["created_at"], record["canal"] or "apprise", f"{record['titulo']}" + (f" — {record['erro'][:120]}" if record["erro"] else "")))
+        for row in conn.execute("SELECT * FROM visitas ORDER BY id DESC LIMIT ?", (limite,)).fetchall():
+            record = row_to_dict(row)
+            entries.append(_entry("visita", "ok", record["created_at"], record["ip"], f"{record['event']} {record['page']}" + (f" · gclid {record['gclid'][:16]}" if record["gclid"] else "")))
+
+    if operacao:
+        entries = [item for item in entries if item["operacao"] == operacao]
+    if estado:
+        entries = [item for item in entries if item["estado"] == estado]
+    entries.sort(key=lambda item: item["data"] or "", reverse=True)
+    return entries[:limite]

package/app/api/notificacoes.py

@@ -0,0 +1,40 @@
+from fastapi import APIRouter, HTTPException
+from pydantic import BaseModel
+
+from ..services import notify
+from ..services.llm import LLMError
+
+router = APIRouter(prefix="/api/notificacoes", tags=["notificacoes"])
+
+
+class ConfigBody(BaseModel):
+    eventos: dict = {}
+    targets: list = []
+
+
+class TesteBody(BaseModel):
+    titulo: str = "Teste ProdMaker"
+    mensagem: str = "Notificação de teste do ProdMaker."
+
+
+@router.get("")
+def config():
+    return notify.listar_config()
+
+
+@router.put("")
+def salvar(body: ConfigBody):
+    return notify.salvar_config(body.eventos, body.targets)
+
+
+@router.get("/historico")
+def historico():
+    return notify.historico()
+
+
+@router.post("/teste")
+def teste(body: TesteBody):
+    try:
+        return notify.enviar("teste", body.titulo, body.mensagem, forcar=True)
+    except LLMError as exc:
+        raise HTTPException(status_code=400, detail=str(exc))

package/app/api/paginas.py

@@ -130,6 +130,14 @@ def publicar(page_id: int):
         )
     updated = _get_or_404(page_id)
     updated["publish_result"] = result
+
+    from ..services.notify import notify_event
+
+    notify_event(
+        "pagina_publicada",
+        "Página publicada",
+        f"{updated['titulo']} — {result['pages_url']}",
+    )
     return updated
 
 

package/app/api/pins.py

@@ -0,0 +1,80 @@
+from fastapi import APIRouter, HTTPException
+from pydantic import BaseModel
+
+from ..services import pinterest
+from ..services.database import get_db, row_to_dict
+from ..services.llm import LLMError
+
+router = APIRouter(prefix="/api/pins", tags=["pinterest"])
+
+
+def _produto_or_none(produto_id: int | None) -> dict:
+    if not produto_id:
+        return {"id": None, "nome": "Produto", "nicho": ""}
+    with get_db() as conn:
+        row = conn.execute("SELECT * FROM produtos WHERE id = ?", (produto_id,)).fetchone()
+    return row_to_dict(row) if row else {"id": produto_id, "nome": "Produto", "nicho": ""}
+
+
+class GerarBody(BaseModel):
+    produto_id: int | None = None
+    board: str = ""
+    link: str = ""
+    quantidade: int = 10
+
+
+class StatusBody(BaseModel):
+    status: str
+
+
+class AgendarBody(BaseModel):
+    imagem_path: str = ""
+
+
+class ExportBody(BaseModel):
+    pin_ids: list = []
+
+
+@router.get("")
+def listar(produto_id: int | None = None):
+    return pinterest.listar(produto_id)
+
+
+@router.post("/gerar")
+def gerar(body: GerarBody):
+    produto = _produto_or_none(body.produto_id)
+    try:
+        return pinterest.gerar_ideias(produto, body.board, body.link, body.quantidade)
+    except LLMError as exc:
+        raise HTTPException(status_code=400, detail=str(exc))
+
+
+@router.put("/{pin_id}/status")
+def status(pin_id: int, body: StatusBody):
+    try:
+        return pinterest.marcar(pin_id, body.status)
+    except LLMError as exc:
+        raise HTTPException(status_code=400, detail=str(exc))
+
+
+@router.post("/{pin_id}/agendar")
+def agendar(pin_id: int, body: AgendarBody):
+    try:
+        return pinterest.agendar(pin_id, body.imagem_path)
+    except LLMError as exc:
+        raise HTTPException(status_code=400, detail=str(exc))
+
+
+@router.post("/export")
+def exportar(body: ExportBody):
+    csv_text = pinterest.exportar_csv([int(item) for item in body.pin_ids])
+    return {"csv": csv_text}
+
+
+@router.delete("/{pin_id}")
+def remover(pin_id: int):
+    try:
+        pinterest.remover(pin_id)
+    except LLMError as exc:
+        raise HTTPException(status_code=404, detail=str(exc))
+    return {"ok": True}

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.09"
+APP_VERSION = "0.1.11"
 COOKIE_NAME = "prodmaker_session"
 SESSION_DAYS = 30
 MASTER_ALIAS = "admin"
@@ -32,6 +32,12 @@ 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
 from .api import ads as ads_router  # noqa: E402
+from .api import lancamentos as lancamentos_router  # noqa: E402
+from .api import notificacoes as notificacoes_router  # noqa: E402
+from .api import dashboard as dashboard_router  # noqa: E402
+from .api import pins as pins_router  # noqa: E402
+from .api import logs as logs_router  # noqa: E402
+from .api import guias as guias_router  # noqa: E402
 
 app.include_router(llm_router.router)
 app.include_router(infoprodutos_router.router)
@@ -40,6 +46,12 @@ app.include_router(dominios_router.router)
 app.include_router(tracking_router.router)
 app.include_router(vendas_router.router)
 app.include_router(ads_router.router)
+app.include_router(lancamentos_router.router)
+app.include_router(notificacoes_router.router)
+app.include_router(dashboard_router.router)
+app.include_router(pins_router.router)
+app.include_router(logs_router.router)
+app.include_router(guias_router.router)
 
 ensure_db()
 
@@ -246,7 +258,7 @@ def health():
 
 @app.get("/api/version")
 def version():
-    return {"version": APP_VERSION, "canonical": "0.1.9"}
+    return {"version": APP_VERSION, "canonical": "0.1.11"}
 
 
 @app.get("/api/settings")

package/app/services/campaigns.py

@@ -144,6 +144,11 @@ def marcar_publicada(campanha_id: int, resultado: dict, status: str = "publicada
             "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)
 
 

package/app/services/database.py

@@ -163,6 +163,51 @@ def ensure_db() -> None:
         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
+            )
+            """
+        )
+        conn.execute(
+            """
+            CREATE TABLE IF NOT EXISTS pins (
+                id INTEGER PRIMARY KEY AUTOINCREMENT,
+                produto_id INTEGER,
+                titulo TEXT NOT NULL,
+                descricao TEXT NOT NULL DEFAULT '',
+                texto_imagem TEXT NOT NULL DEFAULT '',
+                sugestao_imagem TEXT NOT NULL DEFAULT '',
+                board TEXT NOT NULL DEFAULT '',
+                link TEXT NOT NULL DEFAULT '',
+                status TEXT NOT NULL DEFAULT 'ideia',
+                provider TEXT NOT NULL DEFAULT '',
+                erro TEXT NOT NULL DEFAULT '',
+                created_at TEXT NOT NULL
+            )
+            """
+        )
 
 
 def now_str() -> str: