623 lines
25 KiB
Python
623 lines
25 KiB
Python
"""
|
||
routes_catalyst.py
|
||
Meta Marketing API wrappers for The Catalyst module.
|
||
|
||
Routes:
|
||
POST /api/catalyst/campaigns/create — Bulk campaign creation
|
||
POST /api/catalyst/creative/sync — Upload ComfyUI assets to Meta
|
||
GET /api/catalyst/insights/realtime — Poll Ads Insights API
|
||
POST /api/catalyst/audiences/lookalike — Push CRM leads → Meta Custom Audience
|
||
POST /api/catalyst/auth/meta — OAuth token acquisition
|
||
"""
|
||
|
||
from __future__ import annotations
|
||
|
||
import os
|
||
import uuid
|
||
import hashlib
|
||
import logging
|
||
from typing import Any
|
||
from datetime import datetime
|
||
|
||
import httpx
|
||
from fastapi import APIRouter, Depends, HTTPException, Query, Request, status
|
||
from pydantic import BaseModel, Field
|
||
|
||
from backend.auth.dependencies import UserPrincipal, get_current_user
|
||
from backend.services.ad_network_service import (
|
||
AdInsight,
|
||
BidStrategyUpdate,
|
||
BudgetUpdate,
|
||
Platform,
|
||
ad_network_service,
|
||
)
|
||
from backend.services.social_posting import (
|
||
PostRequest,
|
||
PostStatus,
|
||
SocialPlatform,
|
||
SocialPostingConfigurationError,
|
||
SocialPostingError,
|
||
get_post,
|
||
list_posts,
|
||
publish_content,
|
||
publish_due_scheduled,
|
||
)
|
||
|
||
logger = logging.getLogger(__name__)
|
||
|
||
router = APIRouter()
|
||
|
||
# ── Helpers ───────────────────────────────────────────────────────────────────
|
||
|
||
def _get_sdk() -> tuple[Any, str]:
|
||
"""
|
||
Initialise the facebook-business SDK lazily.
|
||
Returns (FacebookAdsApi instance, ad_account_id).
|
||
Raises HTTPException 503 if credentials are missing or SDK init fails.
|
||
"""
|
||
try:
|
||
from facebook_business.api import FacebookAdsApi # type: ignore
|
||
access_token = os.getenv("META_ACCESS_TOKEN", "")
|
||
app_id = os.getenv("META_APP_ID", "")
|
||
app_secret = os.getenv("META_APP_SECRET", "")
|
||
account_id = os.getenv("META_AD_ACCOUNT_ID", "")
|
||
|
||
if not access_token or access_token.startswith("PLACEHOLDER"):
|
||
raise ValueError("META_ACCESS_TOKEN is not configured.")
|
||
if not account_id or account_id.startswith("PLACEHOLDER"):
|
||
raise ValueError("META_AD_ACCOUNT_ID is not configured.")
|
||
|
||
FacebookAdsApi.init(app_id, app_secret, access_token)
|
||
return FacebookAdsApi.get_default_api(), account_id
|
||
except ImportError:
|
||
raise HTTPException(
|
||
status_code=status.HTTP_503_SERVICE_UNAVAILABLE,
|
||
detail="facebook-business SDK not installed. Run: pip install facebook-business",
|
||
)
|
||
except ValueError as exc:
|
||
raise HTTPException(
|
||
status_code=status.HTTP_503_SERVICE_UNAVAILABLE,
|
||
detail=str(exc),
|
||
)
|
||
|
||
|
||
def _get_supabase():
|
||
"""Initialise the Supabase client lazily."""
|
||
try:
|
||
from supabase import create_client # type: ignore
|
||
url = os.getenv("SUPABASE_URL", "")
|
||
key = os.getenv("SUPABASE_SERVICE_ROLE_KEY", "")
|
||
if not url or url.startswith("PLACEHOLDER"):
|
||
raise ValueError("SUPABASE_URL is not configured.")
|
||
return create_client(url, key)
|
||
except ImportError:
|
||
raise HTTPException(
|
||
status_code=status.HTTP_503_SERVICE_UNAVAILABLE,
|
||
detail="supabase SDK not installed. Run: pip install supabase",
|
||
)
|
||
except ValueError as exc:
|
||
raise HTTPException(
|
||
status_code=status.HTTP_503_SERVICE_UNAVAILABLE,
|
||
detail=str(exc),
|
||
)
|
||
|
||
|
||
def _ok(data: Any, meta: dict | None = None) -> dict:
|
||
return {"status": "ok", "data": data, "meta": meta or {}}
|
||
|
||
|
||
def _get_db_pool(request: Request) -> Any:
|
||
pool = getattr(request.app.state, "db_pool", None)
|
||
if pool is None:
|
||
raise HTTPException(status_code=503, detail="Database unavailable.")
|
||
return pool
|
||
|
||
|
||
def _sha256_hash(value: str) -> str:
|
||
"""SHA-256 hash an email for Meta's hashed audience upload."""
|
||
return hashlib.sha256(value.strip().lower().encode()).hexdigest()
|
||
|
||
|
||
# ── Request / Response Models ─────────────────────────────────────────────────
|
||
|
||
class CampaignCreateRequest(BaseModel):
|
||
name: str = Field(..., description="Campaign display name")
|
||
platform: Platform = Field(default=Platform.META, description="Target ad network platform")
|
||
objective: str = Field("OUTCOME_LEADS", description="Meta campaign objective enum")
|
||
budget_daily: int = Field(..., gt=0, description="Daily budget in cents (AED × 100)")
|
||
status: str = Field("PAUSED", description="Initial campaign status — start PAUSED for review")
|
||
special_ad_categories: list[str] = Field(default_factory=list)
|
||
|
||
|
||
class CampaignCreateResponse(BaseModel):
|
||
campaign_id: str
|
||
name: str
|
||
status: str
|
||
created_at: str
|
||
|
||
|
||
class CreativeSyncRequest(BaseModel):
|
||
asset_url: str = Field(..., description="Public URL of the ComfyUI-rendered image or video")
|
||
asset_name: str = Field(..., description="Human-readable asset name")
|
||
asset_type: str = Field(..., description="'image' or 'video'")
|
||
ad_account_id: str | None = Field(None, description="Override ad account ID (optional)")
|
||
|
||
|
||
class LookalikeAudienceRequest(BaseModel):
|
||
country: str = Field("AE", description="ISO 3166-1 alpha-2 country code for lookalike")
|
||
ratio: float = Field(0.01, ge=0.01, le=0.20, description="Lookalike ratio (1%–20%)")
|
||
crm_filter_status: str = Field("Closed/Won", description="Supabase lead status to filter on")
|
||
|
||
|
||
class MetaAuthRequest(BaseModel):
|
||
short_lived_token: str = Field(..., description="Short-lived user access token from Meta OAuth")
|
||
|
||
|
||
@router.get("/campaigns", summary="List unified campaign summaries for the Catalyst marketing tab")
|
||
async def list_campaigns(platform: Platform | None = Query(default=None)) -> dict:
|
||
campaigns = await ad_network_service.list_campaigns(platform=platform)
|
||
insights = await ad_network_service.get_insights(platform=platform, days=7)
|
||
rollup: dict[str, dict[str, float]] = {}
|
||
for insight in insights:
|
||
insight_campaign_id = insight.campaign_id if isinstance(insight, AdInsight) else insight.get("campaign_id")
|
||
if not insight_campaign_id:
|
||
continue
|
||
spent = insight.spend if isinstance(insight, AdInsight) else float(insight.get("spend", 0))
|
||
impressions = insight.impressions if isinstance(insight, AdInsight) else int(insight.get("impressions", 0))
|
||
clicks = insight.clicks if isinstance(insight, AdInsight) else int(insight.get("clicks", 0))
|
||
conversions = insight.conversions if isinstance(insight, AdInsight) else int(insight.get("conversions", 0))
|
||
slot = rollup.setdefault(
|
||
insight_campaign_id,
|
||
{
|
||
"spent": 0.0,
|
||
"impressions": 0.0,
|
||
"clicks": 0.0,
|
||
"conversions": 0.0,
|
||
},
|
||
)
|
||
slot["spent"] += spent
|
||
slot["impressions"] += impressions
|
||
slot["clicks"] += clicks
|
||
slot["conversions"] += conversions
|
||
data = [
|
||
{
|
||
"id": campaign.id,
|
||
"name": campaign.name,
|
||
"platform": campaign.platform.value,
|
||
"status": campaign.status.value,
|
||
"budget": campaign.daily_budget,
|
||
"spent": round(rollup.get(campaign.id, {}).get("spent", campaign.spent), 2),
|
||
"impressions": int(rollup.get(campaign.id, {}).get("impressions", 0)),
|
||
"clicks": int(rollup.get(campaign.id, {}).get("clicks", 0)),
|
||
"conversions": int(rollup.get(campaign.id, {}).get("conversions", 0)),
|
||
"objective": campaign.objective,
|
||
"bid_strategy": campaign.bid_strategy,
|
||
}
|
||
for campaign in campaigns
|
||
]
|
||
source = "ad_network_service_live" if platform else "ad_network_service_unified"
|
||
return _ok(data, meta={"count": len(data), "source": source})
|
||
|
||
|
||
# ── 1. POST /campaigns/create ─────────────────────────────────────────────────
|
||
|
||
@router.post("/campaigns/create", summary="Create Meta or Google marketing campaigns")
|
||
async def create_campaigns(
|
||
request: Request,
|
||
payload: CampaignCreateRequest,
|
||
) -> dict:
|
||
"""
|
||
Triggers `facebook_business.adobjects.campaign.Campaign` to create a campaign
|
||
under the configured Ad Account.
|
||
|
||
Requires: META_ACCESS_TOKEN, META_AD_ACCOUNT_ID
|
||
"""
|
||
if payload.platform == Platform.GOOGLE:
|
||
campaign_id = f"google-camp-{uuid.uuid4().hex[:8]}"
|
||
if hasattr(request.app.state, "broadcast_live_event"):
|
||
await request.app.state.broadcast_live_event(
|
||
"create",
|
||
f"Created Google Ads campaign '{payload.name}'.",
|
||
payload.name,
|
||
f"Budget: AED {payload.budget_daily / 100:.0f}/day",
|
||
)
|
||
return _ok(
|
||
CampaignCreateResponse(
|
||
campaign_id=campaign_id,
|
||
name=payload.name,
|
||
status=payload.status,
|
||
created_at=datetime.utcnow().isoformat(),
|
||
).model_dump(),
|
||
meta={"platform": "google", "mode": "simulated_or_provider_managed"},
|
||
)
|
||
|
||
_api, account_id = _get_sdk()
|
||
|
||
try:
|
||
from facebook_business.adobjects.adaccount import AdAccount # type: ignore
|
||
from facebook_business.adobjects.campaign import Campaign # type: ignore
|
||
|
||
account = AdAccount(account_id)
|
||
params = {
|
||
Campaign.Field.name: payload.name,
|
||
Campaign.Field.objective: payload.objective,
|
||
Campaign.Field.status: payload.status,
|
||
Campaign.Field.daily_budget: payload.budget_daily,
|
||
Campaign.Field.special_ad_categories: payload.special_ad_categories,
|
||
}
|
||
campaign = account.create_campaign(params=params)
|
||
|
||
# Broadcast live event via WebSocket
|
||
if hasattr(request.app.state, "broadcast_live_event"):
|
||
await request.app.state.broadcast_live_event(
|
||
"create",
|
||
f"Created campaign '{payload.name}' (objective: {payload.objective}).",
|
||
payload.name,
|
||
f"Budget: AED {payload.budget_daily / 100:.0f}/day",
|
||
)
|
||
|
||
return _ok(
|
||
CampaignCreateResponse(
|
||
campaign_id=campaign["id"],
|
||
name=payload.name,
|
||
status=payload.status,
|
||
created_at=datetime.utcnow().isoformat(),
|
||
).model_dump(),
|
||
meta={"account_id": account_id},
|
||
)
|
||
except Exception as exc:
|
||
logger.error("Campaign creation failed: %s", exc)
|
||
raise HTTPException(status_code=status.HTTP_502_BAD_GATEWAY, detail=str(exc))
|
||
|
||
|
||
# ── 2. POST /creative/sync ────────────────────────────────────────────────────
|
||
|
||
@router.post("/creative/sync", summary="Upload ComfyUI asset to Meta Ad Library")
|
||
async def sync_creative(
|
||
request: Request,
|
||
payload: CreativeSyncRequest,
|
||
) -> dict:
|
||
"""
|
||
Uploads an image or video URL (from ComfyUI / Wan 2.2 / Qwen-Image 2512) to
|
||
the Meta Ad Library (Creative Hub) and returns the Meta Asset ID.
|
||
|
||
Requires: META_ACCESS_TOKEN, META_AD_ACCOUNT_ID
|
||
"""
|
||
_api, account_id = _get_sdk()
|
||
account_id = payload.ad_account_id or account_id
|
||
|
||
try:
|
||
from facebook_business.adobjects.adaccount import AdAccount # type: ignore
|
||
from facebook_business.adobjects.advideo import AdVideo # type: ignore
|
||
from facebook_business.adobjects.adimage import AdImage # type: ignore
|
||
|
||
account = AdAccount(account_id)
|
||
|
||
if payload.asset_type == "video":
|
||
# Video upload via file_url
|
||
result = account.create_ad_video(params={
|
||
AdVideo.Field.name: payload.asset_name,
|
||
AdVideo.Field.file_url: payload.asset_url,
|
||
})
|
||
meta_asset_id = result["id"]
|
||
else:
|
||
# Image upload via url
|
||
result = account.create_ad_image(params={
|
||
"filename": payload.asset_name,
|
||
"url": payload.asset_url,
|
||
})
|
||
# AdImage returns a hash dict — extract hash key
|
||
meta_asset_id = list(result["images"].values())[0]["hash"] \
|
||
if "images" in result else result.get("id", "unknown")
|
||
|
||
return _ok({
|
||
"meta_asset_id": meta_asset_id,
|
||
"asset_name": payload.asset_name,
|
||
"asset_type": payload.asset_type,
|
||
"uploaded_at": datetime.utcnow().isoformat(),
|
||
})
|
||
except Exception as exc:
|
||
logger.error("Creative sync failed: %s", exc)
|
||
raise HTTPException(status_code=status.HTTP_502_BAD_GATEWAY, detail=str(exc))
|
||
|
||
|
||
# ── 3. GET /insights/realtime ─────────────────────────────────────────────────
|
||
|
||
@router.get("/insights/realtime", summary="Poll unified Meta and Google Ads insights")
|
||
async def get_realtime_insights(
|
||
campaign_id: str | None = None,
|
||
platform: Platform | None = Query(default=None),
|
||
days: int = Query(default=7, ge=1, le=90),
|
||
) -> dict:
|
||
try:
|
||
insights = await ad_network_service.get_insights(campaign_id=campaign_id, platform=platform, days=days)
|
||
except Exception as exc:
|
||
logger.error("Insights fetch failed: %s", exc)
|
||
raise HTTPException(status_code=status.HTTP_502_BAD_GATEWAY, detail=str(exc))
|
||
|
||
data = [item.model_dump() if isinstance(item, AdInsight) else item for item in insights]
|
||
return _ok(data, meta={"count": len(data), "days": days, "platform": platform.value if platform else "all"})
|
||
|
||
|
||
@router.put("/budget", summary="Update Meta or Google Ads budget and campaign status")
|
||
async def update_campaign_budget(request: Request, payload: BudgetUpdate) -> dict:
|
||
try:
|
||
result = await ad_network_service.update_budget(payload)
|
||
if hasattr(request.app.state, "broadcast_live_event"):
|
||
await request.app.state.broadcast_live_event(
|
||
"budget_update",
|
||
f"Updated {payload.platform.value} budget for {payload.campaign_id}.",
|
||
payload.campaign_id,
|
||
f"daily={payload.daily_budget} lifetime={payload.lifetime_budget}",
|
||
)
|
||
return _ok(result)
|
||
except Exception as exc:
|
||
logger.error("Budget update failed: %s", exc)
|
||
raise HTTPException(status_code=status.HTTP_502_BAD_GATEWAY, detail=str(exc))
|
||
|
||
|
||
@router.put("/bid-strategy", summary="Apply Meta or Google Ads bid strategy changes")
|
||
async def update_bid_strategy(request: Request, payload: BidStrategyUpdate) -> dict:
|
||
try:
|
||
action = await ad_network_service.update_bid_strategy(payload)
|
||
if hasattr(request.app.state, "broadcast_live_event"):
|
||
await request.app.state.broadcast_live_event(
|
||
"bid_strategy_update",
|
||
f"Updated {payload.platform.value} bid strategy for {payload.campaign_id}.",
|
||
payload.campaign_id,
|
||
payload.strategy,
|
||
)
|
||
return _ok(action.model_dump())
|
||
except Exception as exc:
|
||
logger.error("Bid strategy update failed: %s", exc)
|
||
raise HTTPException(status_code=status.HTTP_502_BAD_GATEWAY, detail=str(exc))
|
||
|
||
|
||
# ── 4. POST /audiences/lookalike ──────────────────────────────────────────────
|
||
|
||
@router.post("/audiences/lookalike", summary="Push Supabase CRM leads → Meta Lookalike Audience")
|
||
async def create_lookalike_audience(
|
||
request: Request,
|
||
payload: LookalikeAudienceRequest,
|
||
) -> dict:
|
||
"""
|
||
1. Queries the Supabase `leads` table for rows matching `status = payload.crm_filter_status`.
|
||
2. SHA-256 hashes their email addresses.
|
||
3. Creates (or updates) a Meta Custom Audience with the hashed emails.
|
||
4. Creates a Lookalike Audience from that Custom Audience.
|
||
|
||
Requires: META_ACCESS_TOKEN, META_AD_ACCOUNT_ID, SUPABASE_URL, SUPABASE_SERVICE_ROLE_KEY
|
||
"""
|
||
_api, account_id = _get_sdk()
|
||
supabase = _get_supabase()
|
||
|
||
# ── Step 1: Fetch qualified leads from Supabase CRM ──
|
||
try:
|
||
response = supabase.table("leads") \
|
||
.select("id, email, name") \
|
||
.eq("status", payload.crm_filter_status) \
|
||
.execute()
|
||
leads = response.data or []
|
||
except Exception as exc:
|
||
raise HTTPException(status_code=status.HTTP_502_BAD_GATEWAY,
|
||
detail=f"Supabase query failed: {exc}")
|
||
|
||
if not leads:
|
||
return _ok({"message": f"No leads found with status '{payload.crm_filter_status}'."})
|
||
|
||
# ── Step 2: Hash emails ──
|
||
hashed_emails = [
|
||
_sha256_hash(lead["email"])
|
||
for lead in leads
|
||
if lead.get("email")
|
||
]
|
||
if not hashed_emails:
|
||
raise HTTPException(status_code=422, detail="No valid email addresses found in the filtered leads.")
|
||
|
||
# ── Step 3: Create / update Meta Custom Audience ──
|
||
try:
|
||
from facebook_business.adobjects.adaccount import AdAccount # type: ignore
|
||
from facebook_business.adobjects.customaudience import CustomAudience # type: ignore
|
||
|
||
account = AdAccount(account_id)
|
||
audience_name = f"Velocity CRM — {payload.crm_filter_status} Leads"
|
||
|
||
# Create custom audience
|
||
custom_audience = account.create_custom_audience(params={
|
||
CustomAudience.Field.name: audience_name,
|
||
CustomAudience.Field.subtype: "CUSTOM",
|
||
CustomAudience.Field.description: f"Auto-generated from Velocity CRM — {len(hashed_emails)} leads",
|
||
"customer_file_source": "USER_PROVIDED_ONLY",
|
||
})
|
||
audience_id = custom_audience["id"]
|
||
|
||
# Add users via hashed emails
|
||
custom_audience.create_users_replace(params={
|
||
"payload": {
|
||
"schema": ["EMAIL_SHA256"],
|
||
"data": [[h] for h in hashed_emails],
|
||
}
|
||
})
|
||
|
||
# ── Step 4: Create Lookalike Audience ──
|
||
lookalike = account.create_lookalike_audience(params={
|
||
"name": f"Velocity Lookalike — {payload.crm_filter_status} ({int(payload.ratio * 100)}%)",
|
||
"origin_audience_id": audience_id,
|
||
"lookalike_spec": {
|
||
"type": "similarity",
|
||
"ratio": payload.ratio,
|
||
"country": payload.country,
|
||
},
|
||
})
|
||
|
||
# Broadcast live event
|
||
if hasattr(request.app.state, "broadcast_live_event"):
|
||
await request.app.state.broadcast_live_event(
|
||
"create",
|
||
f"Created Lookalike Audience from {len(hashed_emails)} CRM Closed/Won leads.",
|
||
None,
|
||
f"+{len(hashed_emails):,} leads",
|
||
)
|
||
|
||
return _ok({
|
||
"custom_audience_id": audience_id,
|
||
"lookalike_audience_id": lookalike["id"],
|
||
"leads_processed": len(hashed_emails),
|
||
"country": payload.country,
|
||
"ratio": payload.ratio,
|
||
})
|
||
except Exception as exc:
|
||
logger.error("Audience creation failed: %s", exc)
|
||
raise HTTPException(status_code=status.HTTP_502_BAD_GATEWAY, detail=str(exc))
|
||
|
||
|
||
# ── 5. POST /auth/meta ────────────────────────────────────────────────────────
|
||
|
||
@router.post("/auth/meta", summary="Exchange short-lived token for System User token")
|
||
async def meta_oauth(payload: MetaAuthRequest) -> dict:
|
||
"""
|
||
Exchanges a short-lived Meta user token for a long-lived token using the
|
||
`/oauth/access_token` endpoint, then stores it in Supabase for persistence.
|
||
|
||
Requires: META_APP_ID, META_APP_SECRET
|
||
"""
|
||
import httpx
|
||
|
||
app_id = os.getenv("META_APP_ID", "")
|
||
app_secret = os.getenv("META_APP_SECRET", "")
|
||
api_ver = os.getenv("META_API_VERSION", "v21.0")
|
||
|
||
if app_id.startswith("PLACEHOLDER") or app_secret.startswith("PLACEHOLDER"):
|
||
raise HTTPException(
|
||
status_code=status.HTTP_503_SERVICE_UNAVAILABLE,
|
||
detail="META_APP_ID or META_APP_SECRET not configured.",
|
||
)
|
||
|
||
url = f"https://graph.facebook.com/{api_ver}/oauth/access_token"
|
||
params = {
|
||
"grant_type": "fb_exchange_token",
|
||
"client_id": app_id,
|
||
"client_secret": app_secret,
|
||
"fb_exchange_token": payload.short_lived_token,
|
||
}
|
||
|
||
async with httpx.AsyncClient() as client:
|
||
resp = await client.get(url, params=params, timeout=15.0)
|
||
|
||
if resp.status_code != 200:
|
||
raise HTTPException(
|
||
status_code=status.HTTP_502_BAD_GATEWAY,
|
||
detail=f"Meta OAuth error: {resp.text}",
|
||
)
|
||
|
||
token_data = resp.json()
|
||
long_lived_token = token_data.get("access_token")
|
||
|
||
if not long_lived_token:
|
||
raise HTTPException(status_code=502, detail="No access_token in Meta response.")
|
||
|
||
# Persist to Supabase (best-effort — don't block on failure)
|
||
try:
|
||
supabase = _get_supabase()
|
||
supabase.table("catalyst_settings").upsert({
|
||
"key": "META_ACCESS_TOKEN",
|
||
"value": long_lived_token,
|
||
"updated_at": datetime.utcnow().isoformat(),
|
||
}).execute()
|
||
except Exception as exc:
|
||
logger.warning("Could not persist Meta token to Supabase: %s", exc)
|
||
|
||
return _ok({
|
||
"access_token": long_lived_token,
|
||
"token_type": token_data.get("token_type", "bearer"),
|
||
"expires_in": token_data.get("expires_in"),
|
||
})
|
||
|
||
|
||
# ── 6. Social publishing ─────────────────────────────────────────────────────
|
||
|
||
@router.post("/publish", status_code=status.HTTP_201_CREATED, summary="Publish or schedule content to social channels")
|
||
async def api_publish_content(
|
||
payload: PostRequest,
|
||
request: Request,
|
||
user: UserPrincipal = Depends(get_current_user),
|
||
) -> dict:
|
||
try:
|
||
result = await publish_content(
|
||
pool=_get_db_pool(request),
|
||
tenant_id=user.tenant_id,
|
||
actor_id=user.user_id,
|
||
payload=payload,
|
||
)
|
||
except SocialPostingConfigurationError as exc:
|
||
raise HTTPException(status_code=503, detail=str(exc)) from exc
|
||
except ValueError as exc:
|
||
raise HTTPException(status_code=422, detail=f"Invalid schedule_time: {exc}") from exc
|
||
except (SocialPostingError, httpx.HTTPError) as exc:
|
||
raise HTTPException(status_code=502, detail=str(exc)) from exc
|
||
return _ok(result)
|
||
|
||
|
||
@router.get("/posts", summary="List tenant-scoped social posts")
|
||
async def api_list_social_posts(
|
||
request: Request,
|
||
platform: SocialPlatform | None = Query(default=None),
|
||
post_status: PostStatus | None = Query(default=None, alias="status"),
|
||
limit: int = Query(default=50, ge=1, le=200),
|
||
user: UserPrincipal = Depends(get_current_user),
|
||
) -> dict:
|
||
posts = await list_posts(
|
||
pool=_get_db_pool(request),
|
||
tenant_id=user.tenant_id,
|
||
platform=platform,
|
||
status=post_status,
|
||
limit=limit,
|
||
)
|
||
return _ok(posts, meta={"count": len(posts)})
|
||
|
||
|
||
@router.get("/posts/{post_id}", summary="Get a tenant-scoped social post")
|
||
async def api_get_social_post(
|
||
post_id: str,
|
||
request: Request,
|
||
user: UserPrincipal = Depends(get_current_user),
|
||
) -> dict:
|
||
post = await get_post(pool=_get_db_pool(request), tenant_id=user.tenant_id, post_id=post_id)
|
||
if post is None:
|
||
raise HTTPException(status_code=404, detail=f"Social post '{post_id}' not found.")
|
||
return _ok(post)
|
||
|
||
|
||
@router.get("/scheduled", summary="List scheduled social posts for the authenticated tenant")
|
||
async def api_scheduled_posts(
|
||
request: Request,
|
||
limit: int = Query(default=50, ge=1, le=200),
|
||
user: UserPrincipal = Depends(get_current_user),
|
||
) -> dict:
|
||
posts = await list_posts(
|
||
pool=_get_db_pool(request),
|
||
tenant_id=user.tenant_id,
|
||
status=PostStatus.SCHEDULED,
|
||
limit=limit,
|
||
)
|
||
return _ok(posts, meta={"count": len(posts)})
|
||
|
||
|
||
@router.post("/scheduled/publish-due", summary="Publish due scheduled social posts for the authenticated tenant")
|
||
async def api_publish_due_scheduled(
|
||
request: Request,
|
||
limit: int = Query(default=20, ge=1, le=100),
|
||
user: UserPrincipal = Depends(get_current_user),
|
||
) -> dict:
|
||
try:
|
||
result = await publish_due_scheduled(
|
||
pool=_get_db_pool(request),
|
||
tenant_id=user.tenant_id,
|
||
limit=limit,
|
||
)
|
||
except SocialPostingConfigurationError as exc:
|
||
raise HTTPException(status_code=503, detail=str(exc)) from exc
|
||
except (SocialPostingError, httpx.HTTPError) as exc:
|
||
raise HTTPException(status_code=502, detail=str(exc)) from exc
|
||
return _ok(result)
|