@danhachuel/prodmaker 0.1.11 → 0.1.12

package/app/services/dbengine.py

@@ -0,0 +1,195 @@
+"""Camada de abstração de banco — SQLite (padrão) + PostgreSQL/Supabase (DATABASE_URL).
+
+Objetivo (radar Supabase): o sistema aceita `DATABASE_URL` apontando para o PostgreSQL
+do Supabase SEM quebrar a compatibilidade local com SQLite. Todos os serviços continuam
+usando `get_db()` com a mesma API (execute/fetchall/fetchone, context manager, rows
+acessíveis por nome de coluna). Para PostgreSQL os placeholders `?` são traduzidos para
+`%s` e as linhas viram dicts (mesmo acesso por nome).
+
+Multi-tenant (preparado, NÃO implementado): todas as tabelas têm `user_id TEXT DEFAULT ''`.
+Quando o Supabase Auth entrar, basta filtrar por `current_user_id()` (hoje retorna '').
+"""
+import os
+import sqlite3
+import time
+import uuid
+from pathlib import Path
+
+from .store import STATE
+
+
+def now_str() -> str:
+    return time.strftime("%Y-%m-%d %H:%M:%S")
+
+
+def row_to_dict(row) -> dict:
+    if row is None:
+        return {}
+    if isinstance(row, dict):
+        return dict(row)
+    return {key: row[key] for key in row.keys()}
+
+
+def dsn() -> str | None:
+    return (os.environ.get("DATABASE_URL") or "").strip() or None
+
+
+def is_postgres() -> bool:
+    value = dsn()
+    return bool(value and value.startswith(("postgres://", "postgresql://")))
+
+
+def engine_name() -> str:
+    return "postgres" if is_postgres() else "sqlite"
+
+
+def current_user_id() -> str:
+    """Placeholder multi-tenant: vazio enquanto não houver Supabase Auth."""
+    return (os.environ.get("PRODMAKER_USER_ID") or "").strip()
+
+
+def new_user_id() -> str:
+    return str(uuid.uuid4())
+
+
+# ---------------------------------------------------------------------------
+# PostgreSQL — wrapper mínimo (imports preguiçosos de psycopg)
+# ---------------------------------------------------------------------------
+
+
+def _translate(sql: str) -> str:
+    return sql.replace("?", "%s")
+
+
+class _PgRow(dict):
+    """Acesso por nome (row["col"]) como sqlite3.Row."""
+
+
+class _PgResult:
+    def __init__(self, cursor):
+        self._cursor = cursor
+        self._description = cursor.description
+        self._rows = None
+
+    def _materialize(self):
+        if self._rows is None:
+            columns = [col.name for col in self._description] if self._description else []
+            self._rows = [_PgRow(zip(columns, values)) for values in (self._cursor.fetchall() if self._description else [])]
+
+    def fetchall(self):
+        self._materialize()
+        return list(self._rows)
+
+    def fetchone(self):
+        self._materialize()
+        return self._rows[0] if self._rows else None
+
+    @property
+    def lastrowid(self):
+        # PostgreSQL: capturamos o id via RETURNING nas inserções específicas
+        self._materialize()
+        row = self._rows[0] if self._rows else None
+        return row.get("id") if row else None
+
+    def __iter__(self):
+        self._materialize()
+        return iter(self._rows)
+
+
+class _PgConn:
+    def __init__(self, connection):
+        self._conn = connection
+
+    def execute(self, sql: str, params=()):
+        cursor = self._conn.cursor()
+        cursor.execute(_translate(sql), tuple(params or ()))
+        return _PgResult(cursor)
+
+    def executescript(self, sql: str):
+        cursor = self._conn.cursor()
+        cursor.execute(sql)
+        return _PgResult(cursor)
+
+    def commit(self):
+        self._conn.commit()
+
+    def close(self):
+        try:
+            self._conn.rollback()
+        except Exception:  # noqa: BLE001
+            pass
+        self._conn.close()
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, exc_type, exc, tb):
+        if exc_type is None:
+            self._conn.commit()
+        else:
+            self._conn.rollback()
+        self.close()
+
+
+# ---------------------------------------------------------------------------
+# Conexão
+# ---------------------------------------------------------------------------
+
+
+def _sqlite_path():
+    STATE.mkdir(parents=True, exist_ok=True)
+    return STATE / "prodmaker.db"
+
+
+def connect():
+    """Conexão do engine ativo (sqlite padrão; postgres quando DATABASE_URL definido)."""
+    if is_postgres():
+        try:
+            import psycopg
+        except ImportError as exc:
+            raise RuntimeError(
+                "DATABASE_URL definido, mas o driver psycopg não está instalado — "
+                "rode 'pip install psycopg[binary]' (ou 'prodmaker install' com o requirements atualizado)."
+            ) from exc
+        try:
+            connection = psycopg.connect(dsn(), connect_timeout=10)
+        except Exception as exc:  # noqa: BLE001
+            raise RuntimeError(
+                f"Falha ao conectar no PostgreSQL (DATABASE_URL): {exc}. "
+                "Confira a connection string do Supabase ou desdefina DATABASE_URL para voltar ao SQLite local."
+            ) from exc
+        return _PgConn(connection)
+    conn = sqlite3.connect(_sqlite_path())
+    conn.row_factory = sqlite3.Row
+    return conn
+
+
+# Compatibilidade com o nome antigo usado pelos serviços
+def get_db():
+    return connect()
+
+
+# ---------------------------------------------------------------------------
+# Introspecção / migração (dialect-aware)
+# ---------------------------------------------------------------------------
+
+
+def table_columns(conn, table: str) -> list[str]:
+    if is_postgres():
+        rows = (
+            conn.execute(
+                "SELECT column_name AS name FROM information_schema.columns WHERE table_name = %s",
+                (table,),
+            )
+            .fetchall()
+        )
+        return [row["name"] for row in rows]
+    rows = conn.execute(f"PRAGMA table_info({table})").fetchall()
+    return [row["name"] for row in rows]
+
+
+def add_column_if_missing(conn, table: str, column_ddl: str, column_name: str) -> bool:
+    if column_name not in table_columns(conn, table):
+        conn.execute(f"ALTER TABLE {table} ADD COLUMN {column_ddl}")
+        return True
+    return False

package/app/services/invest.py

@@ -0,0 +1,52 @@
+"""Investimento em tráfego — base do ROAS real e do Lucro Líquido."""
+from .database import get_db, now_str, row_to_dict
+from .llm import LLMError
+
+
+def registrar(valor: float, data: str = "", observacao: str = "") -> dict:
+    if float(valor) <= 0:
+        raise LLMError("Informe um valor de investimento maior que zero.")
+    data = (data or "").strip() or now_str()[:10]
+    timestamp = now_str()
+    with get_db() as conn:
+        cursor = conn.execute(
+            "INSERT INTO investimentos (data, valor, fonte, observacao, created_at) VALUES (?, ?, 'manual', ?, ?)",
+            (data, float(valor), observacao.strip(), timestamp),
+        )
+        row = conn.execute("SELECT * FROM investimentos WHERE id = ?", (cursor.lastrowid,)).fetchone()
+    return row_to_dict(row)
+
+
+def listar(limit: int = 60) -> list[dict]:
+    with get_db() as conn:
+        rows = conn.execute("SELECT * FROM investimentos ORDER BY id DESC LIMIT ?", (limit,)).fetchall()
+    return [row_to_dict(row) for row in rows]
+
+
+def remover(investimento_id: int) -> None:
+    with get_db() as conn:
+        cursor = conn.execute("DELETE FROM investimentos WHERE id = ?", (investimento_id,))
+        if cursor.rowcount == 0:
+            raise LLMError("Registro não encontrado.")
+
+
+def resumo_financeiro() -> dict:
+    """ROAS e Lucro Líquido reais (faturamento = receita das vendas aprovadas)."""
+    with get_db() as conn:
+        receita = conn.execute(
+            "SELECT COALESCE(SUM(valor),0) AS r, COALESCE(SUM(comissao),0) AS c FROM vendas WHERE status = 'aprovada'"
+        ).fetchone()
+        investido = conn.execute("SELECT COALESCE(SUM(valor),0) AS t FROM investimentos").fetchone()
+    receita_valor = float(receita["r"] or 0)
+    comissao_valor = float(receita["c"] or 0)
+    investido_valor = float(investido["t"] or 0)
+    roas = round(receita_valor / investido_valor, 2) if investido_valor > 0 else None
+    lucro = round(receita_valor - investido_valor, 2)
+    return {
+        "faturamento": round(receita_valor, 2),
+        "comissao": round(comissao_valor, 2),
+        "investimento": round(investido_valor, 2),
+        "lucro_liquido": lucro,
+        "roas": roas,
+        "tem_investimento": investido_valor > 0,
+    }

package/app/services/oauth_google.py

@@ -0,0 +1,108 @@
+"""Google OAuth 2.0 — conexão de conta com 1 clique (gera o Refresh Token automaticmente).
+
+Fluxo:
+1. `GET /api/google/oauth/url` monta a URL de consentimento (scopes do Google Ads,
+   access_type=offline + prompt=consent para GARANTIR o refresh_token).
+2. O usuário autoriza no popup; o Google redireciona para `redirect_uri`
+   (http://localhost:8188/api/google/callback?code=...).
+3. `GET /api/google/callback` troca o code por tokens e salva o refresh_token em
+   settings.api_keys.google-ads (status "conectado").
+
+Observação: o usuário precisa criar um OAuth Client ID (tipo "Desktop app" ou "Web")
+no Google Cloud, com a URL de redirect autorizada, e colar client_id/secret uma vez
+em Chaves de API. A autorização da conta passa a ser 1 clique.
+"""
+import time
+
+import httpx
+
+from .store import get_settings, save_settings
+
+OAUTH_SCOPE = "https://www.googleapis.com/auth/adwords"
+TOKEN_URL = "https://oauth2.googleapis.com/token"
+AUTH_URL = "https://accounts.google.com/o/oauth2/v2/auth"
+
+
+def callback_url(request=None) -> str:
+    base = "http://localhost:8188"
+    if request is not None:
+        host = request.headers.get("host")
+        base = f"{request.url.scheme}://{host}"
+    return f"{base}/api/google/callback"
+
+
+def build_auth_url(request=None) -> dict:
+    keys = (get_settings().get("api_keys") or {}).get("google-ads") or {}
+    client_id = (keys.get("client_id") or "").strip()
+    if not client_id:
+        from .llm import LLMError
+
+        raise LLMError(
+            "Para conectar com 1 clique, primeiro salve o 'OAuth Client ID' do Google Cloud em Chaves de API (card Google Ads)."
+        )
+    redirect = callback_url(request)
+    import urllib.parse
+
+    query = urllib.parse.urlencode(
+        {
+            "client_id": client_id,
+            "redirect_uri": redirect,
+            "response_type": "code",
+            "scope": OAUTH_SCOPE,
+            "access_type": "offline",
+            "prompt": "consent",  # força a devolução do refresh_token
+            "include_granted_scopes": "true",
+        }
+    )
+    return {"url": f"{AUTH_URL}?{query}", "redirect_uri": redirect}
+
+
+def exchange_code(code: str, request=None) -> dict:
+    keys = (get_settings().get("api_keys") or {}).get("google-ads") or {}
+    client_id = (keys.get("client_id") or "").strip()
+    client_secret = (keys.get("client_secret") or "").strip()
+    if not client_id or not client_secret:
+        from .llm import LLMError
+
+        raise LLMError("client_id e client_secret precisam estar salvos em Chaves de API antes de concluir o OAuth.")
+    redirect = callback_url(request)
+    try:
+        response = httpx.post(
+            TOKEN_URL,
+            data={
+                "client_id": client_id,
+                "client_secret": client_secret,
+                "code": code.strip(),
+                "grant_type": "authorization_code",
+                "redirect_uri": redirect,
+            },
+            timeout=30.0,
+        )
+    except httpx.HTTPError as exc:
+        from .llm import LLMError
+
+        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:
+        from .llm import LLMError
+
+        raise LLMError(
+            f"Google rejeitou a troca do código ({response.status_code}): {response.text[:200]}. "
+            "Confira redirect_uri autorizado e tente novamente.",
+            provider="google-ads",
+        )
+    tokens = response.json() or {}
+    refresh_token = tokens.get("refresh_token")
+    if not refresh_token:
+        from .llm import LLMError
+
+        raise LLMError(
+            "O Google não devolveu refresh_token — apague o app nas configurações da conta Google "
+            "(apps de terceiros conectados) e tente novamente, ou marque prompt=consent."
+        )
+    settings = get_settings()
+    api_keys = settings.setdefault("api_keys", {})
+    google = api_keys.setdefault("google-ads", {})
+    google["refresh_token"] = refresh_token
+    google["connected_at"] = time.strftime("%Y-%m-%dT%H:%M:%S")
+    save_settings(settings)
+    return {"ok": True, "connected_at": google["connected_at"], "scope": tokens.get("scope", OAUTH_SCOPE)}