Files
CenaForge/publisher/app/service.py
T
MateuusandClaude Opus 5.5 84f30bbc2d 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>
2026-11-17 16:35:09 -03:00

585 lines
32 KiB
Python

"""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()