CenaForge: primeira versão pública
Gerador de vídeos narrativos (Godot + FFmpeg), painel Next.js, serviço de voz, Clipador de lives e Publicador para YouTube, TikTok e Instagram. Inclui a leitura das visualizações dos posts para o Dashboard e o botão "Publicar no <rede>" nos cartões das publicações. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
@@ -0,0 +1,584 @@
|
||||
"""Regras do Publicador: apps das redes, perfis (conexão oficial ou sessão), OAuth e execução dos jobs.
|
||||
|
||||
O Publicador é só EXECUTOR: não sabe o que é canal, história ou corte. Recebe um job (arquivo + metadados + perfil),
|
||||
envia e devolve progresso/resultado. Quem decide o quê e quando publicar é o painel.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import json
|
||||
import logging
|
||||
import re
|
||||
import secrets
|
||||
import sqlite3
|
||||
import threading
|
||||
import time
|
||||
import uuid
|
||||
from datetime import datetime, timezone
|
||||
from pathlib import Path
|
||||
from typing import Any, Callable
|
||||
|
||||
import httpx
|
||||
|
||||
from .config import Settings
|
||||
from .db import Database, loads, now
|
||||
from .paths import IMAGE_EXT, VIDEO_EXT, PathRefused, inside_root
|
||||
from .platforms.base import PLATFORMS, JobSpec, Progress, PublishError, PublishResult, Sleep, Tokens, make_verifier
|
||||
from .platforms.instagram_api import InstagramApi
|
||||
from .platforms.session.browser import BrowserInfo, BrowserManager, detect_browser
|
||||
from .platforms.session.common import prune_screenshots
|
||||
from .platforms.session.runner import SessionRunner
|
||||
from .platforms.stats import PostStats, youtube_public
|
||||
from .platforms.tiktok_api import TikTokApi
|
||||
from .platforms.youtube_api import YouTubeApi
|
||||
from .vault import Vault
|
||||
|
||||
log = logging.getLogger("publisher")
|
||||
|
||||
PROFILE_ID = re.compile(r"^[a-z0-9][a-z0-9-]{0,63}--(youtube|tiktok|instagram)$")
|
||||
STATE_TTL_S = 10 * 60
|
||||
SESSION_GAP_S = 30 # intervalo mínimo entre dois envios pelo navegador
|
||||
|
||||
NAMES = {"youtube": "YouTube", "tiktok": "TikTok", "instagram": "Instagram"}
|
||||
APP_NOTES = {
|
||||
"youtube": ("Google Cloud: crie um cliente OAuth do tipo \"App para computador\" (Desktop app), ative a YouTube Data "
|
||||
"API v3 e coloque o app em \"In production\" (em \"Testing\" a autorização vence a cada 7 dias)."),
|
||||
"tiktok": ("TikTok for Developers: app com Login Kit (Desktop) e Content Posting API; cadastre o redirect acima. "
|
||||
"Sem auditoria do TikTok, o Direct Post só sai como privado (Somente eu); o modo Rascunho funciona."),
|
||||
"instagram": ("Meta for Developers: produto \"Instagram API with Instagram Login\". A Meta não aceita redirect para "
|
||||
"este computador, então não há redirect: gere o token no painel do app e cole em Canais de "
|
||||
"publicação. Client ID/Secret aqui são opcionais (só para referência)."),
|
||||
}
|
||||
|
||||
|
||||
class UserError(Exception):
|
||||
def __init__(self, message: str, status: int = 400):
|
||||
super().__init__(message)
|
||||
self.message, self.status = message, status
|
||||
|
||||
|
||||
def iso(epoch: float | None) -> str | None:
|
||||
if not epoch:
|
||||
return None
|
||||
return datetime.fromtimestamp(epoch, timezone.utc).isoformat(timespec="seconds").replace("+00:00", "Z")
|
||||
|
||||
|
||||
def parse_iso(text: str | None) -> float | None:
|
||||
if not text:
|
||||
return None
|
||||
try:
|
||||
return datetime.fromisoformat(text.replace("Z", "+00:00")).timestamp()
|
||||
except ValueError:
|
||||
return None
|
||||
|
||||
|
||||
def profile_view(row: dict) -> dict:
|
||||
return {
|
||||
"profileId": row["profile_id"], "platform": row["platform"], "mode": row["mode"], "status": row["status"],
|
||||
"displayName": row["display_name"], "handle": row["handle"], "connectedAt": row["connected_at"],
|
||||
"expiresAt": row["expires_at"], "lastCheckAt": row["last_check_at"], "lastError": row["last_error"],
|
||||
}
|
||||
|
||||
|
||||
def job_view(row: dict) -> dict:
|
||||
return {
|
||||
"jobId": row["job_id"], "profileId": row["profile_id"], "platform": row["platform"], "status": row["status"],
|
||||
"step": row["step"], "progress": round(float(row["progress"] or 0), 4), "remoteId": row["remote_id"],
|
||||
"url": row["url"], "draft": bool(row["draft"]), "error": row["error"],
|
||||
"createdAt": row["created_at"], "updatedAt": row["updated_at"],
|
||||
}
|
||||
|
||||
|
||||
class Publisher:
|
||||
def __init__(self, settings: Settings, db: Database, vault: Vault, http: httpx.Client | None = None,
|
||||
browsers: BrowserManager | None = None, runner: SessionRunner | None = None,
|
||||
sleep: Sleep = time.sleep, detect: Callable[[], BrowserInfo | None] | None = None):
|
||||
self.settings, self.db, self.vault, self.sleep = settings, db, vault, sleep
|
||||
self.http = http or httpx.Client(timeout=httpx.Timeout(120, connect=15))
|
||||
self._detect = detect or (lambda: detect_browser(settings.browser_path))
|
||||
self.browsers = browsers or BrowserManager(settings.browser_dir, self._detect())
|
||||
self.runner = runner or SessionRunner(self.browsers, settings.logs_dir, sleep)
|
||||
self._refresh_lock = threading.Lock()
|
||||
self._last_session_end = 0.0
|
||||
self._verifiers: dict[str, str] = {} # state → code_verifier do PKCE (só em memória)
|
||||
prune_screenshots(settings.logs_dir)
|
||||
|
||||
# ---------- status
|
||||
def browser_status(self) -> dict:
|
||||
info = self._detect()
|
||||
if info and self.browsers.browser is None:
|
||||
self.browsers.browser = info # instalou o Chrome com o serviço ligado
|
||||
return {"found": bool(info), "kind": info.kind if info else None, "path": info.path if info else None}
|
||||
|
||||
# ---------- apps das redes
|
||||
def _check_platform(self, platform: str) -> None:
|
||||
if platform not in PLATFORMS:
|
||||
raise UserError("Rede desconhecida. Use youtube, tiktok ou instagram.", 404)
|
||||
|
||||
def app_state(self, platform: str) -> dict:
|
||||
self._check_platform(platform)
|
||||
app = self.vault.get(f"app:{platform}") or {}
|
||||
client_id = app.get("clientId") or None
|
||||
configured = bool(client_id and (app.get("clientSecret") or platform == "instagram"))
|
||||
return {"configured": configured, "clientId": client_id,
|
||||
"redirectUri": "" if platform == "instagram" else self.settings.redirect_uri(platform),
|
||||
"notes": APP_NOTES[platform]}
|
||||
|
||||
def set_app(self, platform: str, client_id: str, client_secret: str) -> dict:
|
||||
self._check_platform(platform)
|
||||
client_id, client_secret = client_id.strip(), client_secret.strip()
|
||||
if not client_id:
|
||||
raise UserError("Preencha o Client ID.")
|
||||
if platform != "instagram" and not client_secret:
|
||||
raise UserError("Preencha o Client Secret.")
|
||||
previous = self.vault.get(f"app:{platform}") or {}
|
||||
# Secret em branco no Instagram = manter o que já estava.
|
||||
self.vault.set(f"app:{platform}", {"clientId": client_id,
|
||||
"clientSecret": client_secret or previous.get("clientSecret", "")})
|
||||
return self.app_state(platform)
|
||||
|
||||
def delete_app(self, platform: str) -> dict:
|
||||
self._check_platform(platform)
|
||||
self.vault.delete(f"app:{platform}")
|
||||
return self.app_state(platform)
|
||||
|
||||
def _app(self, platform: str) -> dict:
|
||||
app = self.vault.get(f"app:{platform}") or {}
|
||||
if not app.get("clientId") or not app.get("clientSecret"):
|
||||
raise UserError(f"Antes de conectar pela conta oficial, cadastre o app do {NAMES[platform]} em "
|
||||
"Configurações → Apps das redes.")
|
||||
return app
|
||||
|
||||
def youtube(self) -> YouTubeApi:
|
||||
app = self._app("youtube")
|
||||
return YouTubeApi(self.http, app["clientId"], app["clientSecret"], self.settings.redirect_uri("youtube"), self.sleep)
|
||||
|
||||
def tiktok(self) -> TikTokApi:
|
||||
app = self._app("tiktok")
|
||||
return TikTokApi(self.http, app["clientId"], app["clientSecret"], self.settings.redirect_uri("tiktok"), self.sleep)
|
||||
|
||||
def instagram(self) -> InstagramApi:
|
||||
return InstagramApi(self.http, self.settings.ig_api_version, self.sleep)
|
||||
|
||||
# ---------- perfis
|
||||
def check_profile_id(self, profile_id: str) -> str:
|
||||
match = PROFILE_ID.fullmatch(profile_id or "")
|
||||
if not match:
|
||||
raise UserError("profileId inválido: use \"<canal>--<rede>\" (ex.: historias-do-litoral--youtube).")
|
||||
return match.group(1)
|
||||
|
||||
def _row(self, profile_id: str) -> dict | None:
|
||||
return self.db.get("SELECT * FROM profiles WHERE profile_id = ?", profile_id)
|
||||
|
||||
def _ensure_row(self, profile_id: str) -> dict:
|
||||
platform = self.check_profile_id(profile_id)
|
||||
row = self._row(profile_id)
|
||||
if row:
|
||||
return row
|
||||
self.db.run("INSERT OR IGNORE INTO profiles (profile_id, platform, status, updated_at) VALUES (?, ?, 'disconnected', ?)",
|
||||
profile_id, platform, now())
|
||||
return self._row(profile_id) # type: ignore[return-value]
|
||||
|
||||
def _update(self, profile_id: str, **fields: Any) -> dict:
|
||||
self._ensure_row(profile_id)
|
||||
if fields:
|
||||
columns = ", ".join(f"{name} = ?" for name in fields)
|
||||
self.db.run(f"UPDATE profiles SET {columns}, updated_at = ? WHERE profile_id = ?",
|
||||
*fields.values(), now(), profile_id)
|
||||
return self._row(profile_id) # type: ignore[return-value]
|
||||
|
||||
def profile(self, profile_id: str) -> dict:
|
||||
row = self._ensure_row(profile_id)
|
||||
# Autorização oficial vencida (refresh do TikTok, token do Instagram): marca na leitura.
|
||||
if row["status"] == "connected" and row["mode"] == "official":
|
||||
expires = parse_iso(row["expires_at"])
|
||||
if expires and expires < time.time():
|
||||
row = self._update(profile_id, status="expired",
|
||||
last_error=f"A autorização do {NAMES[row['platform']]} venceu. Conecte de novo.")
|
||||
return profile_view(row)
|
||||
|
||||
def connect(self, profile_id: str, platform: str, mode: str) -> dict:
|
||||
actual = self.check_profile_id(profile_id)
|
||||
if actual != platform:
|
||||
raise UserError(f"O profileId é do {NAMES[actual]}, mas o pedido diz {NAMES.get(platform, platform)}.")
|
||||
if mode == "session":
|
||||
self._update(profile_id, mode="session", status="connecting", last_error=None)
|
||||
try:
|
||||
self.runner.open_for_login(profile_id, platform)
|
||||
except PublishError as exc:
|
||||
self._update(profile_id, status="error", last_error=exc.message)
|
||||
raise UserError(exc.message, 409) from exc
|
||||
return {"profile": self.profile(profile_id), "next": self._browser_next(platform)}
|
||||
if platform == "instagram":
|
||||
self._update(profile_id, mode="official", status="connecting", last_error=None)
|
||||
return {"profile": self.profile(profile_id), "next": {"kind": "paste_token", "help": (
|
||||
"No painel da Meta (developers.facebook.com → seu app → Instagram → \"API setup with Instagram "
|
||||
"login\"), clique em \"Generate token\" ao lado da sua conta profissional, entre com o Instagram e "
|
||||
"copie o token. Cole aqui. Ele vale 60 dias e o CenaForge renova sozinho antes de vencer.")}}
|
||||
api = self.youtube() if platform == "youtube" else self.tiktok()
|
||||
state, verifier = secrets.token_urlsafe(32), make_verifier()
|
||||
self.db.run("DELETE FROM oauth_states WHERE expires_at < ? OR used = 1", time.time())
|
||||
# O code_verifier fica só na memória do processo (nunca no disco). Se o Publicador reiniciar no meio, é só
|
||||
# clicar em Conectar de novo.
|
||||
self._verifiers = {k: v for k, v in self._verifiers.items()
|
||||
if self.db.get("SELECT 1 FROM oauth_states WHERE state = ? AND used = 0", k)}
|
||||
self._verifiers[state] = verifier
|
||||
self.db.run("INSERT INTO oauth_states (state, platform, profile_id, verifier, created_at, expires_at) "
|
||||
"VALUES (?, ?, ?, '', ?, ?)", state, platform, profile_id, time.time(),
|
||||
time.time() + STATE_TTL_S)
|
||||
self._update(profile_id, mode="official", status="connecting", last_error=None)
|
||||
return {"profile": self.profile(profile_id), "next": {"kind": "open_url", "url": api.authorize_url(state, verifier)}}
|
||||
|
||||
@staticmethod
|
||||
def _browser_next(platform: str) -> dict:
|
||||
return {"kind": "browser_opened", "help": (
|
||||
f"Abrimos uma janela do navegador só para o {NAMES[platform]}. Entre na sua conta nela, do jeito normal "
|
||||
"(com a verificação em duas etapas, se tiver). O CenaForge nunca vê nem digita a sua senha. Quando "
|
||||
"terminar, volte aqui e clique em \"Já entrei\". Não feche a janela antes disso.")}
|
||||
|
||||
def paste_token(self, profile_id: str, access_token: str) -> dict:
|
||||
platform = self.check_profile_id(profile_id)
|
||||
if platform != "instagram":
|
||||
raise UserError("Colar token só vale para o Instagram. YouTube e TikTok conectam pela página de autorização.")
|
||||
token = access_token.strip()
|
||||
api = self.instagram()
|
||||
try:
|
||||
info = api.me(token)
|
||||
except PublishError as exc:
|
||||
self._update(profile_id, mode="official", status="error", last_error=exc.message)
|
||||
raise UserError(exc.message) from exc
|
||||
tokens = api.pasted_tokens(token, info)
|
||||
self.vault.set(f"token:{profile_id}", tokens.to_vault())
|
||||
self._update(profile_id, mode="official", status="connected", display_name=info.get("name") or info.get("username"),
|
||||
handle=f"@{info['username']}" if info.get("username") else None, connected_at=now(),
|
||||
expires_at=iso(tokens.access_expires_at), last_check_at=now(), last_error=None,
|
||||
meta_json=json.dumps({"igUserId": info["igUserId"], "accountType": info.get("accountType")}))
|
||||
return self.profile(profile_id)
|
||||
|
||||
def session_check(self, profile_id: str) -> dict:
|
||||
platform = self.check_profile_id(profile_id)
|
||||
row = self._ensure_row(profile_id)
|
||||
if row["mode"] != "session":
|
||||
raise UserError("Este perfil não está no modo Sessão logada. Conecte escolhendo \"Sessão logada\".")
|
||||
try:
|
||||
reason = self.runner.check(profile_id, platform)
|
||||
except PublishError as exc:
|
||||
self._update(profile_id, status="error", last_check_at=now(), last_error=exc.message)
|
||||
return self.profile(profile_id)
|
||||
if reason:
|
||||
self._update(profile_id, status="needs_login", last_check_at=now(),
|
||||
last_error=f"Ainda não está logado: {reason}. Entre na conta na janela aberta e clique em \"Já entrei\".")
|
||||
else:
|
||||
self._update(profile_id, status="connected", last_check_at=now(), last_error=None,
|
||||
connected_at=row["connected_at"] if row["status"] == "connected" else now())
|
||||
return self.profile(profile_id)
|
||||
|
||||
def session_open(self, profile_id: str) -> dict:
|
||||
platform = self.check_profile_id(profile_id)
|
||||
row = self._ensure_row(profile_id)
|
||||
if row["mode"] != "session":
|
||||
raise UserError("Este perfil não está no modo Sessão logada.")
|
||||
try:
|
||||
self.runner.open_for_login(profile_id, platform)
|
||||
except PublishError as exc:
|
||||
raise UserError(exc.message, 409) from exc
|
||||
if row["status"] != "connected":
|
||||
self._update(profile_id, status="connecting")
|
||||
return {"profile": self.profile(profile_id), "next": self._browser_next(platform)}
|
||||
|
||||
# ---------- números dos posts (dashboard)
|
||||
def post_stats(self, profile_id: str, ids: list[str]) -> dict:
|
||||
"""Visualizações/curtidas/comentários dos posts `ids` (id do vídeo no YouTube e TikTok, código do reel no
|
||||
Instagram). YouTube: página pública, em qualquer modo. TikTok e Instagram: janela logada (só modo sessão)."""
|
||||
platform = self.check_profile_id(profile_id)
|
||||
ids = list(dict.fromkeys(i.strip() for i in ids if i and i.strip()))[:200]
|
||||
if not ids:
|
||||
return {"capturedAt": iso(time.time()), "items": [], "missing": []}
|
||||
found: dict[str, PostStats] = {}
|
||||
if platform == "youtube":
|
||||
for video_id in ids:
|
||||
try:
|
||||
stats = youtube_public(self.http, video_id)
|
||||
except httpx.HTTPError:
|
||||
stats = None
|
||||
if stats:
|
||||
found[video_id] = stats
|
||||
else:
|
||||
row = self._ensure_row(profile_id)
|
||||
if row["mode"] != "session":
|
||||
raise UserError(f"Ler os números do {NAMES[platform]} por enquanto só funciona no modo Sessão logada.", 409)
|
||||
try:
|
||||
found = self.runner.read_stats(profile_id, platform, ids)
|
||||
except PublishError as exc:
|
||||
if exc.kind == "needs_login":
|
||||
self._update(profile_id, status="needs_login", last_check_at=now(),
|
||||
last_error=f"Ainda não está logado: {exc.message}")
|
||||
raise UserError(exc.message, 409) from exc
|
||||
return {"capturedAt": iso(time.time()), "items": [found[i].view() for i in ids if i in found],
|
||||
"missing": [i for i in ids if i not in found]}
|
||||
|
||||
def disconnect(self, profile_id: str) -> dict:
|
||||
self._ensure_row(profile_id)
|
||||
self.vault.delete(f"token:{profile_id}")
|
||||
try:
|
||||
self.browsers.remove_profile(profile_id)
|
||||
except PublishError as exc:
|
||||
log.warning("não consegui apagar o perfil de navegador %s: %s", profile_id, exc.message)
|
||||
self.db.run("UPDATE jobs SET status = 'canceled', error = ?, step = 'Cancelado', updated_at = ? "
|
||||
"WHERE profile_id = ? AND status = 'queued'", "O perfil foi desconectado.", now(), profile_id)
|
||||
self.db.run("DELETE FROM oauth_states WHERE profile_id = ?", profile_id)
|
||||
self._update(profile_id, mode=None, status="disconnected", display_name=None, handle=None, connected_at=None,
|
||||
expires_at=None, last_check_at=None, last_error=None, meta_json="{}")
|
||||
return self.profile(profile_id)
|
||||
|
||||
def tiktok_creator_info(self, profile_id: str) -> dict:
|
||||
platform = self.check_profile_id(profile_id)
|
||||
row = self._ensure_row(profile_id)
|
||||
if platform != "tiktok" or row["mode"] != "official" or row["status"] != "connected":
|
||||
raise UserError("Disponível só para um perfil do TikTok conectado pela conta oficial.", 409)
|
||||
try:
|
||||
info = self.tiktok().creator_info(self._token_provider(profile_id, "tiktok")(False))
|
||||
except PublishError as exc:
|
||||
self._apply_error(profile_id, exc)
|
||||
raise UserError(exc.message, 409 if exc.kind != "failed" else 502) from exc
|
||||
return {"nickname": info.get("creator_nickname"), "privacyOptions": list(info.get("privacy_level_options") or []),
|
||||
"maxDurationS": info.get("max_video_post_duration_sec"),
|
||||
"commentDisabled": bool(info.get("comment_disabled")), "duetDisabled": bool(info.get("duet_disabled")),
|
||||
"stitchDisabled": bool(info.get("stitch_disabled"))}
|
||||
|
||||
# ---------- OAuth (YouTube e TikTok)
|
||||
def consume_state(self, state: str, platform: str) -> dict:
|
||||
"""Uso único e validade de 10 min. Devolve a linha do state ou levanta UserError."""
|
||||
cursor = self.db.run("UPDATE oauth_states SET used = 1 WHERE state = ? AND platform = ? AND used = 0 AND expires_at > ?",
|
||||
state or "", platform, time.time())
|
||||
row = self.db.get("SELECT * FROM oauth_states WHERE state = ?", state or "")
|
||||
if cursor.rowcount == 1 and row:
|
||||
return row
|
||||
if not row or row["platform"] != platform:
|
||||
raise UserError("Este link de autorização não é válido. Volte ao painel e clique em Conectar de novo.")
|
||||
if row["used"]:
|
||||
raise UserError("Este link de autorização já foi usado. Volte ao painel e clique em Conectar de novo.")
|
||||
raise UserError("O link de autorização expirou (vale 10 minutos). Volte ao painel e clique em Conectar de novo.")
|
||||
|
||||
def oauth_callback(self, platform: str, params: dict[str, str]) -> str:
|
||||
"""Troca o code pelo token. Devolve a mensagem de sucesso ou levanta UserError."""
|
||||
self._check_platform(platform)
|
||||
if platform == "instagram":
|
||||
raise UserError("O Instagram conecta por token colado, não por este endereço.", 404)
|
||||
row = self.consume_state(params.get("state", ""), platform)
|
||||
profile_id = row["profile_id"]
|
||||
verifier = self._verifiers.pop(row["state"], None)
|
||||
if params.get("error"):
|
||||
message = (f"Você não autorizou o CenaForge no {NAMES[platform]} (ou cancelou). Nada foi conectado; "
|
||||
"pode tentar de novo pelo painel.")
|
||||
self._update(profile_id, status="error", last_error=message)
|
||||
raise UserError(message)
|
||||
code = params.get("code", "")
|
||||
if not code:
|
||||
raise UserError("A rede não devolveu o código de autorização. Tente conectar de novo.")
|
||||
if not verifier:
|
||||
message = "O Publicador foi reiniciado no meio da conexão. Volte ao painel e clique em Conectar de novo."
|
||||
self._update(profile_id, status="error", last_error=message)
|
||||
raise UserError(message)
|
||||
try:
|
||||
if platform == "youtube":
|
||||
api = self.youtube()
|
||||
tokens = api.exchange_code(code, verifier)
|
||||
name, handle, channel_id = api.channel(tokens.access_token)
|
||||
meta = {"channelId": channel_id}
|
||||
else:
|
||||
api = self.tiktok()
|
||||
tokens = api.exchange_code(code, verifier)
|
||||
name, handle = api.user_info(tokens.access_token)
|
||||
meta = {"openId": tokens.extra.get("openId")}
|
||||
except PublishError as exc:
|
||||
self._update(profile_id, status="error", last_error=exc.message)
|
||||
raise UserError(exc.message) from exc
|
||||
self.vault.set(f"token:{profile_id}", tokens.to_vault())
|
||||
self._update(profile_id, mode="official", status="connected", display_name=name, handle=handle,
|
||||
connected_at=now(), expires_at=iso(tokens.refresh_expires_at), last_check_at=now(),
|
||||
last_error=None, meta_json=json.dumps(meta))
|
||||
return f"Conectado{f' como {handle or name}' if (handle or name) else ''}! Pode fechar esta aba e voltar ao painel."
|
||||
|
||||
def _token_provider(self, profile_id: str, platform: str) -> Callable[[bool], str]:
|
||||
key = f"token:{profile_id}"
|
||||
|
||||
def provide(force: bool = False) -> str:
|
||||
with self._refresh_lock:
|
||||
secret = self.vault.get(key) or {}
|
||||
access, expires = secret.get("accessToken"), secret.get("accessExpiresAt") or 0
|
||||
if access and not force and expires - 120 > time.time():
|
||||
return access
|
||||
refresh = secret.get("refreshToken")
|
||||
refresh_expires = secret.get("refreshExpiresAt")
|
||||
if not refresh or (refresh_expires and refresh_expires < time.time()):
|
||||
raise PublishError(f"A autorização do {NAMES[platform]} venceu. Conecte de novo em Canais de publicação.",
|
||||
"expired")
|
||||
api = self.youtube() if platform == "youtube" else self.tiktok()
|
||||
tokens: Tokens = api.refresh(refresh)
|
||||
# TikTok: refresh ROTATIVO — o novo substitui o antigo agora, antes de qualquer outra chamada.
|
||||
fields = {k: v for k, v in tokens.to_vault().items() if v is not None}
|
||||
self.vault.update(key, **fields)
|
||||
if tokens.refresh_expires_at:
|
||||
self._update(profile_id, expires_at=iso(tokens.refresh_expires_at))
|
||||
return tokens.access_token
|
||||
|
||||
return provide
|
||||
|
||||
def maintenance(self) -> None:
|
||||
"""Renova os tokens do Instagram que vencem em menos de 10 dias (rodado pelo worker quando ocioso)."""
|
||||
for row in self.db.all("SELECT profile_id FROM profiles WHERE platform = 'instagram' AND mode = 'official' "
|
||||
"AND status = 'connected'"):
|
||||
try:
|
||||
self._instagram_token(row["profile_id"])
|
||||
except PublishError as exc:
|
||||
self._apply_error(row["profile_id"], exc)
|
||||
except Exception: # noqa: BLE001 - manutenção não pode derrubar o worker
|
||||
log.exception("falha renovando token do Instagram de %s", row["profile_id"])
|
||||
|
||||
def _instagram_token(self, profile_id: str) -> tuple[str, str]:
|
||||
key = f"token:{profile_id}"
|
||||
secret = self.vault.get(key) or {}
|
||||
token, ig_user_id = secret.get("accessToken"), secret.get("igUserId")
|
||||
if not token or not ig_user_id:
|
||||
raise PublishError("O Instagram não tem token salvo. Cole o token de novo em Canais de publicação.", "expired")
|
||||
if (secret.get("accessExpiresAt") or 0) < time.time():
|
||||
raise PublishError("O token do Instagram venceu (60 dias). Gere um novo no painel da Meta e cole de novo.",
|
||||
"expired")
|
||||
api = self.instagram()
|
||||
if api.needs_refresh(secret):
|
||||
tokens = api.refresh(token)
|
||||
self.vault.update(key, accessToken=tokens.access_token, accessExpiresAt=tokens.access_expires_at,
|
||||
obtainedAt=tokens.extra.get("obtainedAt"))
|
||||
self._update(profile_id, expires_at=iso(tokens.access_expires_at))
|
||||
token = tokens.access_token
|
||||
return token, ig_user_id
|
||||
|
||||
# ---------- jobs
|
||||
def validate_job(self, body: dict) -> dict:
|
||||
platform = self.check_profile_id(body["profileId"])
|
||||
if platform != body["platform"]:
|
||||
raise UserError(f"O profileId é do {NAMES[platform]}, mas o job diz {NAMES.get(body['platform'], body['platform'])}.")
|
||||
try:
|
||||
file = inside_root(body["file"], self.settings.repo_root, VIDEO_EXT, "vídeo")
|
||||
cover = inside_root(body["cover"], self.settings.repo_root, IMAGE_EXT, "capa") if body.get("cover") else None
|
||||
except PathRefused as exc:
|
||||
raise UserError(str(exc)) from exc
|
||||
if platform == "youtube" and len(body.get("title") or "") > 100:
|
||||
raise UserError("O título do YouTube pode ter no máximo 100 caracteres.")
|
||||
if platform == "youtube" and not (body.get("title") or "").strip():
|
||||
raise UserError("O vídeo do YouTube precisa de título.")
|
||||
row = self._row(body["profileId"])
|
||||
if not row or row["status"] != "connected":
|
||||
raise UserError(f"O perfil {body['profileId']} não está conectado"
|
||||
f"{' (' + row['status'] + ')' if row else ''}. Conecte a rede antes de publicar.", 409)
|
||||
if body.get("publishAt") and parse_iso(body["publishAt"]) is None:
|
||||
raise UserError("publishAt precisa ser uma data ISO (ex.: 2026-11-18T15:00:00Z).")
|
||||
return {**body, "file": str(file), "cover": str(cover) if cover else None}
|
||||
|
||||
def create_job(self, body: dict) -> tuple[dict, bool]:
|
||||
"""(job, criado?). Com `clientRef` já conhecido devolve o job existente sem revalidar nem criar outro."""
|
||||
ref = body.get("clientRef")
|
||||
if ref:
|
||||
existing = self.db.get("SELECT job_id FROM jobs WHERE client_ref = ?", ref)
|
||||
if existing:
|
||||
return self.job(existing["job_id"]), False
|
||||
clean = self.validate_job(body)
|
||||
job_id = uuid.uuid4().hex
|
||||
stamp = now()
|
||||
try:
|
||||
self.db.run("INSERT INTO jobs (job_id, profile_id, platform, input_json, status, step, progress, created_at, "
|
||||
"updated_at, client_ref) VALUES (?, ?, ?, ?, 'queued', 'Na fila', 0, ?, ?, ?)",
|
||||
job_id, clean["profileId"], clean["platform"], json.dumps(clean, ensure_ascii=False), stamp,
|
||||
stamp, ref)
|
||||
except sqlite3.IntegrityError:
|
||||
# Dois pedidos iguais ao mesmo tempo: o outro ganhou a corrida; devolve o dele.
|
||||
existing = self.db.get("SELECT job_id FROM jobs WHERE client_ref = ?", ref)
|
||||
if not existing:
|
||||
raise
|
||||
return self.job(existing["job_id"]), False
|
||||
return self.job(job_id), True
|
||||
|
||||
def job(self, job_id: str) -> dict:
|
||||
row = self.db.get("SELECT * FROM jobs WHERE job_id = ?", job_id)
|
||||
if not row:
|
||||
raise UserError("Job não encontrado.", 404)
|
||||
return job_view(row)
|
||||
|
||||
def cancel_job(self, job_id: str) -> dict:
|
||||
row = self.db.get("SELECT status FROM jobs WHERE job_id = ?", job_id)
|
||||
if not row:
|
||||
raise UserError("Job não encontrado.", 404)
|
||||
cursor = self.db.run("UPDATE jobs SET status = 'canceled', step = 'Cancelado', updated_at = ? "
|
||||
"WHERE job_id = ? AND status = 'queued'", now(), job_id)
|
||||
if cursor.rowcount != 1:
|
||||
raise UserError("Só dá para cancelar um envio que ainda está na fila (este já começou ou terminou).", 409)
|
||||
return self.job(job_id)
|
||||
|
||||
def queue_size(self) -> int:
|
||||
return int(self.db.get("SELECT COUNT(*) AS n FROM jobs WHERE status = 'queued'")["n"])
|
||||
|
||||
@staticmethod
|
||||
def spec(row: dict) -> JobSpec:
|
||||
data = loads(row["input_json"], {})
|
||||
return JobSpec(
|
||||
job_id=row["job_id"], profile_id=row["profile_id"], platform=row["platform"], file=Path(data["file"]),
|
||||
cover=Path(data["cover"]) if data.get("cover") else None, title=data.get("title") or "",
|
||||
caption=data.get("caption") or "", tags=list(data.get("tags") or []), privacy=data.get("privacy") or "public",
|
||||
publish_at=data.get("publishAt"), ai_generated=bool(data.get("aiGenerated")),
|
||||
made_for_kids=bool(data.get("madeForKids")), tiktok_mode=data.get("tiktokMode") or "direct")
|
||||
|
||||
def _apply_error(self, profile_id: str, exc: PublishError) -> None:
|
||||
if exc.kind == "expired":
|
||||
self._update(profile_id, status="expired", last_error=exc.message)
|
||||
elif exc.kind == "needs_login":
|
||||
self._update(profile_id, status="needs_login", last_error=exc.message, last_check_at=now())
|
||||
|
||||
def execute(self, row: dict, progress: Progress) -> PublishResult:
|
||||
"""Roda um job (chamado pelo worker, uma thread). PublishError sobe para o worker gravar o estado."""
|
||||
spec = self.spec(row)
|
||||
profile = self._row(spec.profile_id)
|
||||
if not profile or profile["mode"] is None or profile["status"] == "disconnected":
|
||||
raise PublishError("O perfil foi desconectado antes do envio. Conecte de novo e tente outra vez.")
|
||||
if profile["status"] in ("needs_login", "expired"):
|
||||
raise PublishError(profile["last_error"] or "É preciso entrar de novo nesta rede.", "needs_login")
|
||||
# O arquivo pode ter sumido entre a criação do job e a vez dele.
|
||||
try:
|
||||
inside_root(str(spec.file), self.settings.repo_root, VIDEO_EXT, "vídeo")
|
||||
if spec.cover:
|
||||
inside_root(str(spec.cover), self.settings.repo_root, IMAGE_EXT, "capa")
|
||||
except PathRefused as exc:
|
||||
raise PublishError(str(exc)) from exc
|
||||
try:
|
||||
if profile["mode"] == "session":
|
||||
result = self._execute_session(spec, progress)
|
||||
elif spec.platform == "youtube":
|
||||
if spec.publish_at and (parse_iso(spec.publish_at) or 0) < time.time() + 5 * 60:
|
||||
spec.publish_at = None # horário já passou (ou quase): publica agora em vez de recusar
|
||||
result = self.youtube().upload(spec, self._token_provider(spec.profile_id, "youtube"), progress)
|
||||
elif spec.platform == "tiktok":
|
||||
result = self.tiktok().upload(spec, self._token_provider(spec.profile_id, "tiktok"), progress)
|
||||
else:
|
||||
token, ig_user_id = self._instagram_token(spec.profile_id)
|
||||
result = self.instagram().upload(spec, token, ig_user_id, progress)
|
||||
except PublishError as exc:
|
||||
self._apply_error(spec.profile_id, exc)
|
||||
if exc.kind == "expired":
|
||||
raise PublishError(exc.message, "needs_login") from exc
|
||||
raise
|
||||
self._update(spec.profile_id, last_error=None)
|
||||
return result
|
||||
|
||||
def _execute_session(self, spec: JobSpec, progress: Progress) -> PublishResult:
|
||||
wait = self._last_session_end + SESSION_GAP_S - time.time()
|
||||
if wait > 0:
|
||||
progress("Aguardando o intervalo mínimo entre envios…", 0.0)
|
||||
self.sleep(wait)
|
||||
try:
|
||||
return self.runner.publish(spec, progress)
|
||||
finally:
|
||||
self._last_session_end = time.time()
|
||||
|
||||
def close(self) -> None:
|
||||
self.browsers.close_all()
|
||||
self.http.close()
|
||||
Reference in New Issue
Block a user