"""API endpoints for celebrity appearances tracking"""
from fastapi import APIRouter, HTTPException, Depends, BackgroundTasks, Query, Body
from typing import List, Dict, Optional
from datetime import datetime, timedelta
import asyncio
import re
import os
import tempfile
import xml.etree.ElementTree as ET
from pydantic import BaseModel
from modules.unified_database import UnifiedDatabase
from modules.tmdb_client import TMDbClient
from modules.podchaser_client import PodchaserClient
from modules.taddy_client import TaddyClient
from modules.plex_client import PlexClient, PlexOAuth
from modules.universal_logger import get_logger
from modules.pushover_notifier import PushoverNotifier, create_notifier_from_config
from modules.settings_manager import SettingsManager
from modules.activity_status import get_activity_manager
from slowapi import Limiter
from slowapi.util import get_remote_address
from web.backend.core.http_client import http_client
from web.backend.core.dependencies import get_current_user, require_admin, get_app_state
logger = get_logger('Appearances')
router = APIRouter(prefix="/api/appearances", tags=["appearances"])
limiter = Limiter(key_func=get_remote_address)
# TMDB image base URL
TMDB_IMAGE_BASE = "https://image.tmdb.org/t/p/w500"
def _enrich_with_roles(appearances: list, conn) -> list:
"""Add all_roles list to appearances that have multiple credit types.
For each appearance with >1 credit type, fetches the distinct
(credit_type, character_name, job_title) from the DB.
"""
multi = [a for a in appearances if len(a.get("all_credit_types", [])) > 1]
if not multi:
return appearances
cursor = conn.cursor()
for a in multi:
cursor.execute("""
SELECT DISTINCT credit_type, character_name, job_title
FROM celebrity_appearances
WHERE celebrity_id = ? AND show_name = ? AND appearance_type = ?
""", (a["celebrity_id"], a["show_name"], a["appearance_type"]))
a["all_roles"] = [
{"credit_type": r[0], "character_name": r[1], "job_title": r[2]}
for r in cursor.fetchall() if r[0]
]
return appearances
async def cache_uncached_posters(db) -> int:
"""
Pre-cache posters for appearances without cached data.
Returns the number of posters cached.
"""
try:
with db.get_connection() as conn:
cursor = conn.cursor()
cursor.execute('''
SELECT id, poster_url FROM celebrity_appearances
WHERE poster_data IS NULL AND poster_url IS NOT NULL AND poster_url != ''
LIMIT 50
''')
rows = cursor.fetchall()
cached = 0
for row in rows:
appearance_id = row[0]
poster_url = row[1]
try:
if poster_url.startswith('http'):
url = poster_url
else:
url = f"{TMDB_IMAGE_BASE}{poster_url}"
response = await http_client.get(url)
if response.status_code == 200 and response.content:
with db.get_connection(for_write=True) as conn:
cursor = conn.cursor()
cursor.execute(
'UPDATE celebrity_appearances SET poster_data = ? WHERE id = ?',
(response.content, appearance_id)
)
conn.commit()
cached += 1
except Exception:
pass # Continue with next poster
# Small delay to avoid rate limiting
await asyncio.sleep(0.1)
if cached > 0:
logger.info(f"Pre-cached {cached} appearance posters")
return cached
except Exception as e:
logger.warning(f"Error pre-caching posters: {e}")
return 0
async def download_poster_image(poster_path: str) -> Optional[str]:
"""
Download a TMDB poster image to a temporary file.
Returns the path to the temp file, or None if download failed.
The caller is responsible for cleaning up the temp file.
"""
if not poster_path:
return None
try:
# Construct full URL
if poster_path.startswith('http'):
url = poster_path
else:
url = f"{TMDB_IMAGE_BASE}{poster_path}"
# Download the image
response = await http_client.get(url)
if response.status_code != 200:
logger.warning(f"Failed to download poster: {url} (status {response.status_code})")
return None
# Determine file extension
content_type = response.headers.get('content-type', '')
if 'png' in content_type:
ext = '.png'
elif 'gif' in content_type:
ext = '.gif'
else:
ext = '.jpg'
# Save to temp file
fd, temp_path = tempfile.mkstemp(suffix=ext)
try:
os.write(fd, response.content)
finally:
os.close(fd)
return temp_path
except Exception as e:
logger.error(f"Error downloading poster {poster_path}: {e}")
return None
# Request models
class SyncRequest(BaseModel):
celebrity_ids: Optional[List[int]] = None
# Dependency
def get_db():
return get_app_state().db
# Helper function to backfill audio URLs from RSS feeds
async def backfill_audio_urls_from_rss(celebrity_id: int, db: UnifiedDatabase):
"""
Backfill missing audio URLs by parsing podcast RSS feeds for Omny.fm hosted podcasts
"""
try:
with db.get_connection(for_write=True) as conn:
cursor = conn.cursor()
# Get podcast shows for this celebrity that use Omny.fm and have missing audio URLs
cursor.execute("""
SELECT DISTINCT show_name, poster_url
FROM celebrity_appearances
WHERE celebrity_id = ?
AND appearance_type = 'Podcast'
AND audio_url IS NULL
AND poster_url LIKE '%omnycontent.com%'
""", (celebrity_id,))
shows = cursor.fetchall()
if not shows:
return
for show_name, poster_url in shows:
try:
# Extract RSS URL from poster URL
match = re.search(r'/d/programs/([^/]+)/([^/]+)/', poster_url)
if not match:
continue
podcast_id = match.group(1)
show_id = match.group(2)
rss_url = f"https://www.omnycontent.com/d/playlist/{podcast_id}/{show_id}/ec2a36b6-26e2-41a9-b72b-af1f0112e1ed/podcast.rss"
# Fetch and parse RSS feed
response = await http_client.get(rss_url)
root = ET.fromstring(response.content)
# Extract episode audio URLs
episodes_in_feed = {}
for item in root.findall('.//item'):
title_elem = item.find('title')
enclosure_elem = item.find('enclosure')
if title_elem is not None and enclosure_elem is not None:
title = title_elem.text
audio_url = enclosure_elem.get('url')
if title and audio_url:
episodes_in_feed[title.strip()] = audio_url
if not episodes_in_feed:
continue
# Get episodes from database that need audio URLs
cursor.execute("""
SELECT id, episode_title
FROM celebrity_appearances
WHERE celebrity_id = ?
AND show_name = ?
AND appearance_type = 'Podcast'
AND audio_url IS NULL
""", (celebrity_id, show_name))
db_episodes = cursor.fetchall()
updated = 0
for db_id, episode_title in db_episodes:
# Try exact match first
if episode_title in episodes_in_feed:
audio_url = episodes_in_feed[episode_title]
cursor.execute(
"UPDATE celebrity_appearances SET audio_url = ? WHERE id = ?",
(audio_url, db_id)
)
updated += 1
if updated > 0:
conn.commit()
logger.info(f"Backfilled {updated} audio URLs from RSS feed for {show_name}")
except Exception as e:
logger.error(f"Error backfilling audio URLs for {show_name}: {e}")
continue
except Exception as e:
logger.error(f"Error in backfill_audio_urls_from_rss: {e}")
@router.get("/upcoming")
async def get_upcoming_appearances(
limit: int = Query(5, ge=1, le=100),
days_ahead: int = Query(30, ge=1, le=3650), # Up to 10 years for movies announced far in advance
current_user: Dict = Depends(get_current_user),
db: UnifiedDatabase = Depends(get_db)
):
"""
Get upcoming appearances sorted by date
Returns next N appearances within days_ahead window
Groups by show so multiple roles (acting+producing) are combined into one row
"""
try:
cutoff_date = (datetime.now() + timedelta(days=days_ahead)).isoformat()
query = '''
WITH ShowStats AS (
SELECT
celebrity_id,
show_name,
appearance_type,
COUNT(DISTINCT COALESCE(season_number, 0) || '-' || COALESCE(episode_number, 0) || '-' || COALESCE(CAST(appearance_date AS TEXT), '')) as episode_count,
GROUP_CONCAT(DISTINCT credit_type) as all_credit_types,
MIN(appearance_date) as first_date
FROM celebrity_appearances
WHERE appearance_date >= date('now')
AND appearance_date <= ?
AND status = 'upcoming'
GROUP BY celebrity_id, show_name, appearance_type
),
RankedAppearances AS (
SELECT
ca.*,
ROW_NUMBER() OVER (
PARTITION BY
CASE WHEN ca.appearance_type IN ('TV', 'Podcast', 'Movie')
THEN ca.celebrity_id || '-' || ca.show_name || '-' || ca.appearance_type
ELSE CAST(ca.id AS TEXT)
END
ORDER BY ca.appearance_date ASC, ca.season_number ASC, ca.episode_number ASC
) as rn
FROM celebrity_appearances ca
WHERE
ca.appearance_date >= date('now')
AND ca.appearance_date <= ?
AND ca.status = 'upcoming'
)
SELECT
r.id,
r.celebrity_id,
r.celebrity_name,
r.appearance_type,
r.show_name,
r.episode_title,
r.network,
r.appearance_date,
r.url,
r.audio_url,
r.watch_url,
r.description,
r.tmdb_show_id,
r.season_number,
r.episode_number,
r.status,
r.poster_url,
COALESCE(ss.episode_count, 1) as episode_count,
r.credit_type,
r.character_name,
r.job_title,
r.plex_rating_key,
r.plex_show_rating_key,
ss.all_credit_types
FROM RankedAppearances r
LEFT JOIN ShowStats ss ON r.celebrity_id = ss.celebrity_id
AND r.show_name = ss.show_name AND r.appearance_type = ss.appearance_type
WHERE r.rn = 1
ORDER BY r.appearance_date ASC
LIMIT ?
'''
with db.get_connection() as conn:
cursor = conn.cursor()
cursor.execute(query, (cutoff_date, cutoff_date, limit))
rows = cursor.fetchall()
appearances = []
for row in rows:
# Parse all_credit_types into a list
all_credit_types = row[23].split(',') if row[23] else [row[18]] if row[18] else []
appearances.append({
"id": row[0],
"celebrity_id": row[1],
"celebrity_name": row[2],
"appearance_type": row[3],
"show_name": row[4],
"episode_title": row[5],
"network": row[6],
"appearance_date": row[7],
"url": row[8],
"audio_url": row[9],
"watch_url": row[10],
"description": row[11],
"tmdb_show_id": row[12],
"season_number": row[13],
"episode_number": row[14],
"status": row[15],
"poster_url": row[16],
"episode_count": row[17],
"credit_type": row[18],
"character_name": row[19],
"job_title": row[20],
"plex_rating_key": row[21],
"plex_watch_url": None, # No Plex links for upcoming - episodes haven't aired yet
"all_credit_types": all_credit_types,
})
return _enrich_with_roles(appearances, conn)
except Exception as e:
logger.error(f"Error fetching upcoming appearances: {e}")
raise HTTPException(status_code=500, detail=str(e))
@router.get("/aired")
async def get_aired_appearances(
limit: int = Query(20, ge=1, le=100),
days_back: int = Query(36500, ge=1, le=36500), # 100 years - essentially all history
current_user: Dict = Depends(get_current_user),
db: UnifiedDatabase = Depends(get_db)
):
"""
Get aired (past) appearances sorted by date (most recent first)
Returns N aired appearances within days_back window (default: all history)
Groups TV shows and podcasts by show (showing most recent episode only)
"""
try:
cutoff_date = (datetime.now() - timedelta(days=days_back)).isoformat()
# Use same grouping logic as /all endpoint - group TV and Podcasts by show
query = '''
WITH ShowStats AS (
SELECT
celebrity_id,
show_name,
appearance_type,
COUNT(DISTINCT COALESCE(season_number, 0) || '-' || COALESCE(episode_number, 0) || '-' || COALESCE(CAST(appearance_date AS TEXT), '')) as episode_count,
GROUP_CONCAT(DISTINCT credit_type) as all_credit_types,
MAX(appearance_date) as last_date
FROM celebrity_appearances
WHERE appearance_type IN ('TV', 'Podcast')
AND appearance_date < datetime('now')
AND appearance_date >= ?
AND status = 'aired'
GROUP BY celebrity_id, show_name, appearance_type
),
RankedAppearances AS (
SELECT
ca.*,
ROW_NUMBER() OVER (
PARTITION BY
CASE WHEN ca.appearance_type IN ('TV', 'Podcast')
THEN ca.celebrity_id || '-' || ca.show_name || '-' || ca.appearance_type
ELSE CAST(ca.id AS TEXT)
END
ORDER BY ca.appearance_date DESC, ca.season_number DESC, ca.episode_number DESC
) as rn
FROM celebrity_appearances ca
WHERE
ca.appearance_date < datetime('now')
AND ca.appearance_date >= ?
AND ca.status = 'aired'
)
SELECT
r.id,
r.celebrity_id,
r.celebrity_name,
r.appearance_type,
r.show_name,
r.episode_title,
r.network,
CASE
WHEN r.appearance_type IN ('TV', 'Podcast') AND ss.episode_count > 1 THEN ss.last_date
ELSE r.appearance_date
END as appearance_date,
r.url,
r.audio_url,
r.watch_url,
r.description,
r.tmdb_show_id,
r.season_number,
r.episode_number,
r.status,
r.poster_url,
COALESCE(ss.episode_count, 1) as episode_count,
r.credit_type,
r.character_name,
r.job_title,
r.plex_rating_key,
r.plex_show_rating_key,
ss.all_credit_types
FROM RankedAppearances r
LEFT JOIN ShowStats ss ON r.celebrity_id = ss.celebrity_id
AND r.show_name = ss.show_name AND r.appearance_type = ss.appearance_type
WHERE r.rn = 1
ORDER BY appearance_date DESC
LIMIT ?
'''
with db.get_connection() as conn:
cursor = conn.cursor()
cursor.execute(query, (cutoff_date, cutoff_date, limit))
rows = cursor.fetchall()
# Get Plex config for watch URLs
plex_url = None
plex_machine_id = None
try:
cursor.execute("SELECT plex_url, plex_machine_id FROM appearance_config WHERE id = 1")
plex_row = cursor.fetchone()
if plex_row:
plex_url = plex_row[0]
plex_machine_id = plex_row[1]
except Exception as e:
logger.debug(f"Could not fetch Plex config: {e}")
appearances = []
for row in rows:
plex_watch_url = None
plex_app_url = None
episode_count = row[17]
# Use show key for multi-episode shows, episode key for single episodes
# Use episode rating_key if available, fall back to show rating_key
plex_key = row[21] if row[21] else row[22]
if plex_key and plex_url and plex_machine_id:
plex_watch_url = f"{plex_url}/web/index.html#!/server/{plex_machine_id}/details?key=/library/metadata/{plex_key}"
plex_app_url = f"plex://play?metadataKey=/library/metadata/{plex_key}&server={plex_machine_id}"
# Parse all_credit_types into a list
all_credit_types = row[23].split(',') if row[23] else [row[18]] if row[18] else []
appearances.append({
"id": row[0],
"celebrity_id": row[1],
"celebrity_name": row[2],
"appearance_type": row[3],
"show_name": row[4],
"episode_title": row[5],
"network": row[6],
"appearance_date": row[7],
"url": row[8],
"audio_url": row[9],
"watch_url": row[10],
"description": row[11],
"tmdb_show_id": row[12],
"season_number": row[13],
"episode_number": row[14],
"status": row[15],
"poster_url": row[16],
"episode_count": row[17],
"credit_type": row[18],
"character_name": row[19],
"job_title": row[20],
"plex_rating_key": row[21],
"plex_watch_url": plex_watch_url,
"plex_app_url": plex_app_url,
"all_credit_types": all_credit_types,
})
return _enrich_with_roles(appearances, conn)
except Exception as e:
logger.error(f"Error fetching aired appearances: {e}")
raise HTTPException(status_code=500, detail=str(e))
@router.get("/all")
async def get_all_appearances(
status: Optional[str] = Query(None),
appearance_type: Optional[str] = Query(None),
celebrity_name: Optional[str] = Query(None),
credit_type: Optional[str] = Query(None, description="Filter by credit type: acting, directing, producing, writing, creator, guest"),
search: Optional[str] = Query(None),
date_filter: Optional[str] = Query(None),
start_date: Optional[str] = Query(None),
end_date: Optional[str] = Query(None),
plex_only: bool = Query(False, description="Only show items available in Plex library"),
current_user: Dict = Depends(get_current_user),
db: UnifiedDatabase = Depends(get_db)
):
"""
Get all appearances with optional server-side filtering
Groups podcast episodes by show (shows most recent episode, includes episode count)
Supports filtering by credit_type (acting, directing, producing, writing, creator, guest)
Supports plex_only filter to show only items matched to Plex library
"""
try:
# Build WHERE clauses
where_clauses = []
params = []
# Status filter
if status and status != 'all':
where_clauses.append("status = ?")
params.append(status)
# Appearance type filter
if appearance_type and appearance_type != 'all':
where_clauses.append("appearance_type = ?")
params.append(appearance_type)
# Celebrity filter
if celebrity_name and celebrity_name != 'all':
where_clauses.append("celebrity_name = ?")
params.append(celebrity_name)
# Credit type filter
if credit_type and credit_type != 'all':
where_clauses.append("credit_type = ?")
params.append(credit_type)
# Plex only filter - only show items with specific episode/movie key (not just show key)
if plex_only:
where_clauses.append("plex_rating_key IS NOT NULL")
# Search filter
if search:
where_clauses.append("(celebrity_name LIKE ? OR show_name LIKE ? OR network LIKE ? OR episode_title LIKE ?)")
search_param = f"%{search}%"
params.extend([search_param, search_param, search_param, search_param])
# Date filter
if date_filter == '7days':
where_clauses.append("appearance_date >= datetime('now', '-7 days') AND appearance_date <= datetime('now', '+7 days')")
elif date_filter == '30days':
where_clauses.append("appearance_date >= datetime('now', '-30 days') AND appearance_date <= datetime('now', '+30 days')")
elif date_filter == 'custom' and start_date and end_date:
where_clauses.append("appearance_date >= ? AND appearance_date <= ?")
params.extend([start_date, end_date])
# Build final query
where_sql = " AND ".join(where_clauses) if where_clauses else "1=1"
# Sort ascending for upcoming (soonest first), descending for others (most recent first)
order_direction = "ASC" if status == "upcoming" else "DESC"
# Grouping strategy:
# - TV/Podcast: Group ALL episodes by show (including guests)
# - Movies: Group multiple roles on same movie together
query = f'''
WITH ShowStats AS (
SELECT
celebrity_id,
show_name,
appearance_type,
COUNT(DISTINCT COALESCE(season_number, 0) || '-' || COALESCE(episode_number, 0) || '-' || COALESCE(CAST(appearance_date AS TEXT), '')) as episode_count,
GROUP_CONCAT(DISTINCT credit_type) as all_credit_types,
MIN(appearance_date) as first_date,
MAX(appearance_date) as last_date
FROM celebrity_appearances
WHERE {where_sql}
GROUP BY celebrity_id, show_name, appearance_type
),
RankedAppearances AS (
SELECT
id, celebrity_id, celebrity_name, appearance_type, show_name,
episode_title, network, appearance_date, url, audio_url, watch_url,
description, tmdb_show_id, season_number, episode_number, status,
created_at, updated_at, poster_url, credit_type, character_name,
job_title, plex_rating_key, plex_show_rating_key,
ROW_NUMBER() OVER (
PARTITION BY celebrity_id, show_name, appearance_type
ORDER BY appearance_date DESC, season_number DESC, episode_number DESC
) as row_num
FROM celebrity_appearances
WHERE {where_sql}
)
SELECT
r.id, r.celebrity_id, r.celebrity_name, r.appearance_type, r.show_name,
r.episode_title, r.network,
CASE
WHEN r.appearance_type IN ('TV', 'Podcast') AND ss.episode_count > 1 THEN ss.last_date
ELSE r.appearance_date
END as appearance_date,
r.url, r.audio_url, r.watch_url, r.description, r.tmdb_show_id,
r.season_number, r.episode_number, r.status, r.created_at, r.updated_at,
r.poster_url, COALESCE(ss.episode_count, 1) as episode_count,
r.credit_type, r.character_name, r.job_title, r.plex_rating_key,
r.plex_show_rating_key, ss.all_credit_types
FROM RankedAppearances r
LEFT JOIN ShowStats ss ON r.celebrity_id = ss.celebrity_id
AND r.show_name = ss.show_name AND r.appearance_type = ss.appearance_type
WHERE r.row_num = 1
ORDER BY r.appearance_date {order_direction}
'''
with db.get_connection() as conn:
cursor = conn.cursor()
cursor.execute(query, params + params) # params twice for the 2 WHERE clauses
rows = cursor.fetchall()
# Get Plex config for generating watch URLs
plex_url = None
plex_machine_id = None
try:
cursor.execute("SELECT plex_url, plex_machine_id FROM appearance_config WHERE id = 1")
plex_row = cursor.fetchone()
if plex_row:
plex_url = plex_row[0]
plex_machine_id = plex_row[1]
except Exception as e:
logger.debug(f"Could not fetch Plex config: {e}")
appearances = []
for row in rows:
plex_watch_url = None
plex_app_url = None
episode_count = row[19]
# Use show key for multi-episode shows, episode key for single episodes
# Use episode rating_key if available, fall back to show rating_key
plex_key = row[23] if row[23] else row[24]
if plex_key and plex_url and plex_machine_id:
# Web URL for browser
plex_watch_url = f"{plex_url}/web/index.html#!/server/{plex_machine_id}/details?key=/library/metadata/{plex_key}"
# App URL for opening in Plex app directly
plex_app_url = f"plex://play?metadataKey=/library/metadata/{plex_key}&server={plex_machine_id}"
# Parse all_credit_types into a list
all_credit_types = row[25].split(',') if row[25] else [row[20]] if row[20] else []
appearances.append({
"id": row[0],
"celebrity_id": row[1],
"celebrity_name": row[2],
"appearance_type": row[3],
"show_name": row[4],
"episode_title": row[5],
"network": row[6],
"appearance_date": row[7],
"url": row[8],
"audio_url": row[9],
"watch_url": row[10],
"description": row[11],
"tmdb_show_id": row[12],
"season_number": row[13],
"episode_number": row[14],
"status": row[15],
"created_at": row[16],
"updated_at": row[17],
"poster_url": row[18],
"episode_count": row[19],
"credit_type": row[20],
"character_name": row[21],
"job_title": row[22],
"plex_rating_key": row[23],
"plex_watch_url": plex_watch_url,
"plex_app_url": plex_app_url,
"all_credit_types": all_credit_types,
})
return _enrich_with_roles(appearances, conn)
except Exception as e:
logger.error(f"Error fetching all appearances: {e}")
raise HTTPException(status_code=500, detail=str(e))
@router.get("/tv/grouped")
async def get_tv_grouped(
status: Optional[str] = Query(None),
role_filter: Optional[str] = Query(None),
credit_type: Optional[str] = Query(None, description="Filter by credit type: acting, directing, producing, writing, creator"),
days_back: int = Query(36500, ge=1, le=36500),
days_ahead: int = Query(90, ge=1, le=365),
limit: int = Query(100, ge=1, le=1000),
current_user: Dict = Depends(get_current_user),
db: UnifiedDatabase = Depends(get_db)
):
"""
Get TV appearances grouped by show name
Similar to podcast grouping - shows most recent episode and total count
Includes role information (actress, producer, director, etc.)
Supports filtering by credit_type (acting, directing, producing, writing, creator)
"""
try:
# Date range
start_date = (datetime.now() - timedelta(days=days_back)).isoformat()
end_date = (datetime.now() + timedelta(days=days_ahead)).isoformat()
# Build WHERE clauses
where_clauses = [
"appearance_type = 'TV'",
"appearance_date >= ?",
"appearance_date <= ?"
]
params = [start_date, end_date]
if status and status != 'all':
where_clauses.append("status = ?")
params.append(status)
if role_filter and role_filter != 'all':
where_clauses.append("role_type LIKE ?")
params.append(f"%{role_filter}%")
if credit_type and credit_type != 'all':
where_clauses.append("credit_type = ?")
params.append(credit_type)
where_sql = " AND ".join(where_clauses)
# Group by show, get most recent episode and count
query = f'''
WITH RankedShows AS (
SELECT
id,
celebrity_id,
celebrity_name,
show_name,
episode_title,
network,
appearance_date,
season_number,
episode_number,
status,
role_type,
tmdb_show_id,
description,
poster_url,
credit_type,
character_name,
job_title,
plex_rating_key,
ROW_NUMBER() OVER (
PARTITION BY show_name
ORDER BY appearance_date DESC
) as row_num
FROM celebrity_appearances
WHERE {where_sql}
),
ShowStats AS (
SELECT
show_name,
COUNT(DISTINCT COALESCE(season_number, 0) || '-' || COALESCE(episode_number, 0) || '-' || COALESCE(CAST(appearance_date AS TEXT), '')) as episode_count,
MIN(appearance_date) as first_appearance,
MAX(appearance_date) as last_appearance,
GROUP_CONCAT(DISTINCT role_type) as all_roles,
GROUP_CONCAT(DISTINCT credit_type) as all_credit_types
FROM celebrity_appearances
WHERE {where_sql}
GROUP BY show_name
)
SELECT
r.id,
r.celebrity_id,
r.celebrity_name,
r.show_name,
r.episode_title,
r.network,
r.appearance_date,
r.season_number,
r.episode_number,
r.status,
r.role_type,
r.tmdb_show_id,
r.description,
r.poster_url,
s.episode_count,
s.first_appearance,
s.last_appearance,
s.all_roles,
r.credit_type,
r.character_name,
r.job_title,
r.plex_rating_key,
s.all_credit_types
FROM RankedShows r
INNER JOIN ShowStats s ON r.show_name = s.show_name
WHERE r.row_num = 1
ORDER BY r.appearance_date DESC
LIMIT ?
'''
with db.get_connection() as conn:
cursor = conn.cursor()
cursor.execute(query, params + params + [limit])
rows = cursor.fetchall()
shows = []
for row in rows:
shows.append({
"id": row[0],
"celebrity_id": row[1],
"celebrity_name": row[2],
"show_name": row[3],
"latest_episode_title": row[4],
"network": row[5],
"latest_appearance_date": row[6],
"latest_season": row[7],
"latest_episode": row[8],
"status": row[9],
"latest_role": row[10],
"tmdb_show_id": row[11],
"description": row[12],
"poster_url": row[13],
"episode_count": row[14],
"first_appearance": row[15],
"last_appearance": row[16],
"all_roles": row[17], # Comma-separated list of all roles
"credit_type": row[18],
"character_name": row[19],
"job_title": row[20],
"plex_rating_key": row[21],
"all_credit_types": row[22].split(',') if row[22] else [row[18]] if row[18] else [],
})
return shows
except Exception as e:
logger.error(f"Error fetching grouped TV shows: {e}")
raise HTTPException(status_code=500, detail=str(e))
@router.get("/config")
async def get_appearance_config(
current_user: Dict = Depends(get_current_user),
db: UnifiedDatabase = Depends(get_db)
):
"""Get appearance tracking configuration"""
try:
with db.get_connection() as conn:
cursor = conn.cursor()
cursor.execute('''
SELECT tmdb_enabled, tmdb_check_interval_hours,
notify_new_appearances, notify_days_before,
sync_past_movies, tmdb_api_key, tmdb_last_check,
podcast_enabled, radio_enabled,
podchaser_api_key, podchaser_enabled, podchaser_last_check,
plex_url, plex_token,
notify_include_poster, notify_plex_matches,
taddy_user_id, taddy_api_key, taddy_enabled, taddy_last_check,
taddy_lookback_days, taddy_max_results, plex_sync_enabled,
taddy_user_id_2, taddy_api_key_2
FROM appearance_config WHERE id = 1
''')
row = cursor.fetchone()
if not row:
raise HTTPException(status_code=404, detail="Configuration not found")
return {
"tmdb_enabled": bool(row[0]),
"tmdb_check_interval_hours": row[1],
"notify_new_appearances": bool(row[2]),
"notify_days_before": row[3],
"sync_past_movies": bool(row[4]),
"tmdb_api_key": row[5],
"tmdb_last_check": row[6],
"podcast_enabled": bool(row[7]) if row[7] is not None else False,
"radio_enabled": bool(row[8]) if row[8] is not None else False,
"podchaser_api_key": row[9],
"podchaser_enabled": bool(row[10]) if row[10] is not None else False,
"podchaser_last_check": row[11],
"plex_url": row[12],
"plex_token": row[13],
"notify_include_poster": bool(row[14]) if row[14] is not None else True,
"notify_plex_matches": bool(row[15]) if row[15] is not None else True,
"taddy_user_id": row[16],
"taddy_api_key": row[17],
"taddy_enabled": bool(row[18]) if row[18] is not None else False,
"taddy_last_check": row[19],
"taddy_lookback_days": row[20] or 730,
"taddy_max_results": row[21] or 250,
"plex_sync_enabled": bool(row[22]) if row[22] is not None else False,
"taddy_user_id_2": row[23],
"taddy_api_key_2": row[24],
}
except HTTPException:
raise
except Exception as e:
logger.error(f"Error fetching appearance config: {e}")
raise HTTPException(status_code=500, detail=str(e))
@router.put("/config")
async def update_appearance_config(
config: Dict = Body(...),
current_user: Dict = Depends(get_current_user),
db: UnifiedDatabase = Depends(get_db)
):
"""Update appearance tracking configuration"""
try:
with db.get_connection(for_write=True) as conn:
cursor = conn.cursor()
# Build update query based on provided fields
updates = []
params = []
if "tmdb_enabled" in config:
updates.append("tmdb_enabled = ?")
params.append(1 if config["tmdb_enabled"] else 0)
if "tmdb_check_interval_hours" in config:
updates.append("tmdb_check_interval_hours = ?")
params.append(config["tmdb_check_interval_hours"])
if "notify_new_appearances" in config:
updates.append("notify_new_appearances = ?")
params.append(1 if config["notify_new_appearances"] else 0)
if "notify_days_before" in config:
updates.append("notify_days_before = ?")
params.append(config["notify_days_before"])
if "sync_past_movies" in config:
updates.append("sync_past_movies = ?")
params.append(1 if config["sync_past_movies"] else 0)
if "notify_include_poster" in config:
updates.append("notify_include_poster = ?")
params.append(1 if config["notify_include_poster"] else 0)
if "notify_plex_matches" in config:
updates.append("notify_plex_matches = ?")
params.append(1 if config["notify_plex_matches"] else 0)
# Taddy settings
if "taddy_user_id" in config:
updates.append("taddy_user_id = ?")
params.append(config["taddy_user_id"])
if "taddy_api_key" in config:
updates.append("taddy_api_key = ?")
params.append(config["taddy_api_key"])
if "taddy_enabled" in config:
updates.append("taddy_enabled = ?")
params.append(1 if config["taddy_enabled"] else 0)
if "taddy_lookback_days" in config:
updates.append("taddy_lookback_days = ?")
params.append(config["taddy_lookback_days"])
if "taddy_max_results" in config:
updates.append("taddy_max_results = ?")
params.append(config["taddy_max_results"])
if "taddy_user_id_2" in config:
updates.append("taddy_user_id_2 = ?")
params.append(config["taddy_user_id_2"])
if "taddy_api_key_2" in config:
updates.append("taddy_api_key_2 = ?")
params.append(config["taddy_api_key_2"])
if "plex_sync_enabled" in config:
updates.append("plex_sync_enabled = ?")
params.append(1 if config["plex_sync_enabled"] else 0)
if updates:
query = f"UPDATE appearance_config SET {', '.join(updates)}, updated_at = CURRENT_TIMESTAMP WHERE id = 1"
cursor.execute(query, params)
conn.commit()
return {"success": True, "message": "Configuration updated"}
except Exception as e:
logger.error(f"Error updating appearance config: {e}")
raise HTTPException(status_code=500, detail=str(e))
# ==================== APPEARANCE NOTIFICATIONS (must be before /{appearance_id}) ====================
@router.get("/notifications")
async def get_appearance_notifications(
limit: int = Query(50, ge=1, le=200),
offset: int = Query(0, ge=0),
notification_type: Optional[str] = Query(None, description="Filter by type: reminder, new_appearance, plex_match"),
current_user: Dict = Depends(get_current_user),
db: UnifiedDatabase = Depends(get_db)
):
"""Get appearance notification history"""
try:
with db.get_connection() as conn:
cursor = conn.cursor()
where_clauses = ["1=1"]
where_clauses_aliased = ["1=1"]
params = []
if notification_type:
where_clauses.append("notification_type = ?")
where_clauses_aliased.append("n.notification_type = ?")
params.append(notification_type)
where_sql = " AND ".join(where_clauses)
where_sql_aliased = " AND ".join(where_clauses_aliased)
# Get total count
cursor.execute(f'''
SELECT COUNT(*) FROM appearance_notifications
WHERE {where_sql}
''', params)
total = cursor.fetchone()[0]
# Get Plex config for building watch URLs
plex_url = None
plex_machine_id = None
try:
cursor.execute("SELECT plex_url, plex_machine_id FROM appearance_config WHERE id = 1")
plex_row = cursor.fetchone()
if plex_row:
plex_url = plex_row[0]
plex_machine_id = plex_row[1]
except Exception as e:
logger.debug(f"Could not fetch Plex config: {e}")
# Get notifications with Plex rating key from appearances
cursor.execute(f'''
SELECT n.id, n.appearance_id, n.celebrity_name, n.show_name, n.appearance_type,
n.appearance_date, n.notification_type, n.message, n.poster_url, n.sent_at,
a.plex_rating_key
FROM appearance_notifications n
LEFT JOIN celebrity_appearances a ON n.appearance_id = a.id
WHERE {where_sql_aliased}
ORDER BY COALESCE(n.sent_at, n.created_at) DESC
LIMIT ? OFFSET ?
''', params + [limit, offset])
notifications = []
for row in cursor.fetchall():
plex_watch_url = None
plex_app_url = None
plex_rating_key = row[10]
if plex_rating_key and plex_url and plex_machine_id:
plex_watch_url = f"{plex_url}/web/index.html#!/server/{plex_machine_id}/details?key=/library/metadata/{plex_rating_key}"
plex_app_url = f"plex://play?metadataKey=/library/metadata/{plex_rating_key}&server={plex_machine_id}"
notifications.append({
"id": row[0],
"appearance_id": row[1],
"celebrity_name": row[2],
"show_name": row[3],
"appearance_type": row[4],
"appearance_date": row[5],
"notification_type": row[6],
"message": row[7],
"poster_url": row[8],
"sent_at": row[9],
"plex_watch_url": plex_watch_url,
"plex_app_url": plex_app_url,
})
return {
"success": True,
"notifications": notifications,
"total": total,
"limit": limit,
"offset": offset
}
except Exception as e:
logger.error(f"Error getting appearance notifications: {e}")
raise HTTPException(status_code=500, detail=str(e))
@router.get("/notifications/stats")
async def get_appearance_notification_stats(
current_user: Dict = Depends(get_current_user),
db: UnifiedDatabase = Depends(get_db)
):
"""Get notification statistics"""
try:
with db.get_connection() as conn:
cursor = conn.cursor()
# Get counts by type
cursor.execute('''
SELECT notification_type, COUNT(*) as count
FROM appearance_notifications
GROUP BY notification_type
''')
by_type = {row[0]: row[1] for row in cursor.fetchall()}
# Get today's count
cursor.execute('''
SELECT COUNT(*) FROM appearance_notifications
WHERE date(sent_at) = date('now')
''')
today = cursor.fetchone()[0]
# Get total
cursor.execute('SELECT COUNT(*) FROM appearance_notifications')
total = cursor.fetchone()[0]
return {
"success": True,
"stats": {
"total": total,
"today": today,
"by_type": by_type
}
}
except Exception as e:
logger.error(f"Error getting notification stats: {e}")
raise HTTPException(status_code=500, detail=str(e))
@router.post("/notifications/send-reminders")
async def trigger_appearance_reminders(
current_user: Dict = Depends(get_current_user),
db: UnifiedDatabase = Depends(get_db)
):
"""Manually trigger appearance reminder check"""
try:
result = await send_appearance_reminders(db)
return result
except Exception as e:
logger.error(f"Error triggering reminders: {e}")
raise HTTPException(status_code=500, detail=str(e))
@router.get("/{appearance_id}")
async def get_appearance_details(
appearance_id: int,
current_user: Dict = Depends(get_current_user),
db: UnifiedDatabase = Depends(get_db)
):
"""Get full details for a single appearance"""
try:
query = '''
SELECT
id, celebrity_id, celebrity_name, appearance_type, show_name,
episode_title, network, appearance_date, announcement_date,
url, watch_url, description, tmdb_show_id, tmdb_episode_id,
season_number, episode_number, status, notified,
created_at, updated_at
FROM celebrity_appearances
WHERE id = ?
'''
with db.get_connection() as conn:
cursor = conn.cursor()
cursor.execute(query, (appearance_id,))
row = cursor.fetchone()
if not row:
raise HTTPException(status_code=404, detail="Appearance not found")
return {
"id": row[0],
"celebrity_id": row[1],
"celebrity_name": row[2],
"appearance_type": row[3],
"show_name": row[4],
"episode_title": row[5],
"network": row[6],
"appearance_date": row[7],
"announcement_date": row[8],
"url": row[9],
"watch_url": row[10],
"description": row[11],
"tmdb_show_id": row[12],
"tmdb_episode_id": row[13],
"season_number": row[14],
"episode_number": row[15],
"status": row[16],
"notified": row[17],
"created_at": row[18],
"updated_at": row[19],
}
except HTTPException:
raise
except Exception as e:
logger.error(f"Error fetching appearance {appearance_id}: {e}")
raise HTTPException(status_code=500, detail=str(e))
@router.get("/poster/{appearance_id}")
async def get_appearance_poster(
appearance_id: int,
current_user: Dict = Depends(get_current_user),
db: UnifiedDatabase = Depends(get_db)
):
"""
Get cached poster for an appearance.
Falls back to fetching and caching if not available.
"""
from fastapi.responses import Response
with db.get_connection() as conn:
cursor = conn.cursor()
cursor.execute(
'SELECT poster_data, poster_url FROM celebrity_appearances WHERE id = ?',
(appearance_id,)
)
row = cursor.fetchone()
if not row:
raise HTTPException(status_code=404, detail="Appearance not found")
poster_data = row[0]
poster_url = row[1]
# Serve cached data if available
if poster_data:
return Response(
content=poster_data,
media_type='image/jpeg',
headers={'Cache-Control': 'public, max-age=86400, immutable'}
)
# Fetch and cache if not available
if poster_url:
try:
if poster_url.startswith('http'):
url = poster_url
else:
url = f"{TMDB_IMAGE_BASE}{poster_url}"
response = await http_client.get(url)
if response.status_code == 200 and response.content:
# Cache in database
with db.get_connection(for_write=True) as conn:
cursor = conn.cursor()
cursor.execute(
'UPDATE celebrity_appearances SET poster_data = ? WHERE id = ?',
(response.content, appearance_id)
)
conn.commit()
return Response(
content=response.content,
media_type='image/jpeg',
headers={'Cache-Control': 'public, max-age=86400, immutable'}
)
except Exception as e:
logger.warning(f"Failed to fetch poster for appearance {appearance_id}: {e}")
raise HTTPException(status_code=404, detail="Poster not available")
@router.get("/show/episodes")
async def get_show_episodes(
celebrity_id: int = Query(...),
show_name: str = Query(...),
appearance_type: str = Query('Podcast'), # 'Podcast' or 'TV'
current_user: Dict = Depends(get_current_user),
db: UnifiedDatabase = Depends(get_db)
):
"""Get all episodes for a specific show (podcast or TV).
Groups multiple credit types on the same episode into one entry.
"""
try:
query = '''
SELECT
id,
episode_title,
appearance_date,
season_number,
episode_number,
url,
audio_url,
watch_url,
description,
status,
role_type,
credit_type,
character_name,
job_title,
plex_rating_key
FROM celebrity_appearances
WHERE celebrity_id = ?
AND show_name = ?
AND appearance_type = ?
ORDER BY appearance_date DESC, season_number DESC, episode_number DESC
'''
with db.get_connection() as conn:
cursor = conn.cursor()
# Get plex config for generating watch URLs
cursor.execute("SELECT plex_url, plex_machine_id FROM appearance_config WHERE id = 1")
config_row = cursor.fetchone()
plex_url = config_row[0] if config_row else None
plex_machine_id = config_row[1] if config_row else None
cursor.execute(query, (celebrity_id, show_name, appearance_type))
rows = cursor.fetchall()
# Group rows by episode (season_number + episode_number + appearance_date)
# to combine multiple credit types into one entry
episode_map = {} # key -> episode dict
for row in rows:
sn = row[3] or 0
en = row[4] or 0
ep_date = row[2] or ''
key = f"{sn}-{en}-{ep_date}"
if key not in episode_map:
plex_rating_key = row[14]
plex_watch_url = None
plex_app_url = None
if plex_rating_key and plex_url and plex_machine_id:
plex_watch_url = f"{plex_url}/web/index.html#!/server/{plex_machine_id}/details?key=/library/metadata/{plex_rating_key}"
plex_app_url = f"plex://play?metadataKey=/library/metadata/{plex_rating_key}&server={plex_machine_id}"
episode_map[key] = {
"id": row[0],
"episode_title": row[1],
"appearance_date": row[2],
"season_number": row[3],
"episode_number": row[4],
"url": row[5],
"audio_url": row[6],
"watch_url": row[7],
"description": row[8],
"status": row[9],
"role_type": row[10],
"credit_type": row[11],
"character_name": row[12],
"job_title": row[13],
"plex_rating_key": plex_rating_key,
"plex_watch_url": plex_watch_url,
"plex_app_url": plex_app_url,
"all_credit_types": [row[11]] if row[11] else [],
"all_roles": [{"credit_type": row[11], "character_name": row[12], "job_title": row[13]}] if row[11] else [],
}
else:
ep = episode_map[key]
if row[11] and row[11] not in ep["all_credit_types"]:
ep["all_credit_types"].append(row[11])
ep["all_roles"].append({"credit_type": row[11], "character_name": row[12], "job_title": row[13]})
return list(episode_map.values())
except Exception as e:
logger.error(f"Error fetching episodes for show {show_name}: {e}")
raise HTTPException(status_code=500, detail=str(e))
@router.post("/sync")
async def sync_appearances(
background_tasks: BackgroundTasks,
request: SyncRequest = Body(default=SyncRequest()),
current_user: Dict = Depends(get_current_user),
db: UnifiedDatabase = Depends(get_db)
):
"""
Trigger TMDb sync for all or specific celebrities
Runs in background.
Manual syncs do NOT send push notifications (only scheduled syncs do).
"""
background_tasks.add_task(
sync_tmdb_appearances,
celebrity_ids=request.celebrity_ids,
from_scheduler=False # Manual syncs don't send notifications
)
celeb_count = len(request.celebrity_ids) if request.celebrity_ids else "all"
return {
"success": True,
"message": f"Syncing appearances for {celeb_count} celebrities"
}
@router.get("/sync/status")
async def get_sync_status(current_user: Dict = Depends(get_current_user)):
"""Get the current sync progress status from database (works across processes)"""
activity_manager = get_activity_manager()
task_status = activity_manager.get_background_task("tmdb_sync")
if task_status and task_status.get('active'):
extra = task_status.get('extra_data', {}) or {}
return {
"is_running": True,
"current_celebrity": extra.get('current_celebrity'),
"celebrities_processed": task_status.get('progress', {}).get('current', 0),
"total_celebrities": task_status.get('progress', {}).get('total', 0),
"new_appearances": extra.get('new_appearances', 0),
"started_at": task_status.get('start_time'),
"last_update": task_status.get('updated_at'),
"phase": extra.get('phase'),
"current_show": extra.get('current_show'),
"shows_processed": extra.get('shows_processed', 0),
"total_shows": extra.get('total_shows', 0),
"current_podcast": extra.get('current_podcast'),
"podcasts_processed": extra.get('podcasts_processed', 0),
"total_podcasts": extra.get('total_podcasts', 0),
}
# Not running - return default state
return {
"is_running": False,
"current_celebrity": None,
"celebrities_processed": 0,
"total_celebrities": 0,
"new_appearances": 0,
"started_at": None,
"last_update": None,
"phase": None,
"current_show": None,
"shows_processed": 0,
"total_shows": 0,
"current_podcast": None,
"podcasts_processed": 0,
"total_podcasts": 0,
}
@router.put("/{appearance_id}/status")
async def update_appearance_status(
appearance_id: int,
status: str,
current_user: Dict = Depends(get_current_user),
db: UnifiedDatabase = Depends(get_db)
):
"""Update appearance status (upcoming/aired/watched/ignored)"""
valid_statuses = ["upcoming", "aired", "watched", "ignored"]
if status not in valid_statuses:
raise HTTPException(
status_code=400,
detail=f"Invalid status. Must be one of: {valid_statuses}"
)
try:
with db.get_connection(for_write=True) as conn:
cursor = conn.cursor()
cursor.execute('''
UPDATE celebrity_appearances
SET status = ?, updated_at = CURRENT_TIMESTAMP
WHERE id = ?
''', (status, appearance_id))
conn.commit()
if cursor.rowcount == 0:
raise HTTPException(status_code=404, detail="Appearance not found")
return {"success": True, "status": status}
except HTTPException:
raise
except Exception as e:
logger.error(f"Error updating appearance status: {e}")
raise HTTPException(status_code=500, detail=str(e))
@router.post("/update-status")
async def update_appearance_statuses(
current_user: Dict = Depends(get_current_user),
db: UnifiedDatabase = Depends(get_db)
):
"""Manually trigger status update for past appearances"""
try:
updated_count = update_past_appearances_status(db)
return {
"success": True,
"updated_count": updated_count,
"message": f"Updated {updated_count} appearance(s) to 'aired' status"
}
except Exception as e:
logger.error(f"Error in update status endpoint: {e}")
raise HTTPException(status_code=500, detail=str(e))
# Helper function for notifications
def send_appearance_notification(notifier: PushoverNotifier, celebrity_name: str, appearance: Dict, db: UnifiedDatabase = None) -> bool:
"""
Send a Pushover notification for a new celebrity appearance
Args:
notifier: PushoverNotifier instance
celebrity_name: Name of the celebrity
appearance: Appearance data dict
db: UnifiedDatabase instance for recording notification (optional)
Returns:
True if notification sent successfully
"""
import tempfile
import os
from web.backend.core.http_client import http_client
poster_path = None
try:
# Format the air date
air_date_str = appearance.get("appearance_date", "Unknown date")
try:
air_date = datetime.fromisoformat(air_date_str)
formatted_date = air_date.strftime("%B %d, %Y") # "January 4, 2026"
day_of_week = air_date.strftime("%A") # "Monday"
time_until = air_date - datetime.now()
days_until = time_until.days
except (ValueError, TypeError):
formatted_date = air_date_str
day_of_week = ""
days_until = 0
# Build title based on appearance type
appearance_type = appearance.get("appearance_type", "TV")
show_name = appearance.get("show_name") or appearance.get("movie_name", "Unknown")
if appearance_type == "Movie":
title = f"š¬ New Movie: {celebrity_name}"
elif appearance_type == "Podcast":
title = f"šļø New Podcast: {celebrity_name}"
else:
title = f"šŗ New TV Appearance: {celebrity_name}"
# Build rich HTML message with all details
message_parts = []
# Show/Movie/Podcast info
if appearance_type == "Movie":
message_parts.append(f"š¬ Movie: {show_name}")
elif appearance_type == "Podcast":
message_parts.append(f"šļø Podcast: {show_name}")
else:
message_parts.append(f"šŗ Show: {show_name}")
if appearance.get("network"):
message_parts.append(f"š” Network: {appearance['network']}")
# Episode details
if appearance.get("episode_title"):
episode_info = appearance["episode_title"]
if appearance.get("season_number") and appearance.get("episode_number"):
episode_info = f"S{appearance['season_number']}E{appearance['episode_number']}: {episode_info}"
message_parts.append(f"šļø Episode: {episode_info}")
elif appearance.get("season_number") and appearance.get("episode_number"):
message_parts.append(f"šļø Episode: S{appearance['season_number']}E{appearance['episode_number']}")
# Air/Release date with countdown
if appearance_type == "Movie":
date_label = "Releases"
elif appearance_type == "Podcast":
date_label = "Published"
else:
date_label = "Airs"
if days_until > 0:
if days_until == 1:
countdown = "Tomorrow!"
else:
countdown = f"In {days_until} days"
message_parts.append(f"š
{date_label}: {day_of_week}, {formatted_date} ({countdown})")
else:
message_parts.append(f"š
{date_label}: {day_of_week}, {formatted_date}")
# Description if available
if appearance.get("description"):
desc = appearance["description"]
# Truncate description if too long
if len(desc) > 200:
desc = desc[:197] + "..."
message_parts.append(f"\nš Summary: {desc}")
# Discovery timestamp
now = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
message_parts.append(f"\nā° Discovered: {now}")
message = "\n".join(message_parts)
# Download poster if available
poster_path = None
poster_url_path = appearance.get("poster_url")
if poster_url_path:
try:
# Check if it's already a full URL (podcasts) or a TMDb path
if poster_url_path.startswith("http"):
poster_url = poster_url_path
else:
# TMDb image URL format
poster_url = f"https://image.tmdb.org/t/p/w500{poster_url_path}"
# Download poster to temp file
import asyncio
response = asyncio.run(http_client.get(poster_url))
if response.status_code == 200:
# Create temp file - strip query params before getting extension
url_path = poster_url.split('?')[0]
suffix = os.path.splitext(url_path)[1] or '.jpg'
fd, poster_path = tempfile.mkstemp(suffix=suffix, prefix='tmdb_poster_')
# Write image data
with os.fdopen(fd, 'wb') as f:
f.write(response.content)
logger.debug(f"Downloaded poster to {poster_path}")
else:
logger.warning(f"Failed to download poster: HTTP {response.status_code} for {poster_url}")
except Exception as e:
logger.warning(f"Failed to download poster: {e}")
poster_path = None
# Send notification with poster image
result = notifier.send_notification(
title=title,
message=message,
html=True,
priority=0, # Normal priority
image_path=poster_path
)
# Cleanup temp file
if poster_path and os.path.exists(poster_path):
try:
os.remove(poster_path)
except Exception as e:
logger.warning(f"Failed to remove temp poster file: {e}")
# Record notification to database if successful and db provided
if result and db:
try:
with db.get_connection(for_write=True) as conn:
cursor = conn.cursor()
full_message = f"{title}\n{message}"
cursor.execute('''
INSERT INTO appearance_notifications
(appearance_id, celebrity_name, show_name, appearance_type,
appearance_date, notification_type, message, poster_url,
is_sent, sent_at)
VALUES (?, ?, ?, ?, ?, 'new_appearance', ?, ?, 1, CURRENT_TIMESTAMP)
''', (
appearance.get('id'),
celebrity_name,
show_name,
appearance_type,
air_date_str[:10] if air_date_str and len(air_date_str) >= 10 else air_date_str,
full_message,
appearance.get('poster_url')
))
conn.commit()
except Exception as e:
logger.warning(f"Failed to record appearance notification: {e}")
return result
except Exception as e:
logger.error(f"Error sending appearance notification: {e}")
# Cleanup temp file on error
if poster_path and os.path.exists(poster_path):
try:
os.remove(poster_path)
except OSError:
pass # File cleanup failure is non-critical
return False
def update_past_appearances_status(db: UnifiedDatabase) -> int:
"""
Update status of appearances that have passed from 'upcoming' to 'aired'
Args:
db: UnifiedDatabase instance
Returns:
Number of appearances updated
"""
try:
with db.get_connection(for_write=True) as conn:
cursor = conn.cursor()
# Update appearances where air date has passed but status is still 'upcoming'
# Use date('now') to only mark as aired after the day has ended
cursor.execute('''
UPDATE celebrity_appearances
SET status = 'aired', updated_at = CURRENT_TIMESTAMP
WHERE appearance_date < date('now')
AND status = 'upcoming'
''')
updated_count = cursor.rowcount
conn.commit()
if updated_count > 0:
logger.info(f"Updated {updated_count} past appearance(s) to 'aired' status")
return updated_count
except Exception as e:
logger.error(f"Error updating past appearances status: {e}")
return 0
# Background task
async def sync_tmdb_appearances(celebrity_ids: Optional[List[int]] = None, from_scheduler: bool = False, db=None):
"""
Sync TMDb appearances for celebrities
1. Get TMDb API key from config
2. For each celebrity, fetch upcoming TV appearances
3. Insert/update celebrity_appearances table
Args:
celebrity_ids: Optional list of celebrity IDs to sync (None = all)
from_scheduler: If True, send push notifications for new appearances.
Only the scheduler should set this to True.
db: Optional database instance (required when called from scheduler)
"""
if db is None:
db = get_app_state().db
activity_manager = get_activity_manager()
# Track extra data for the sync progress
sync_extra_data = {
"current_celebrity": None,
"new_appearances": 0,
"phase": None,
"current_show": None,
"shows_processed": 0,
"total_shows": 0,
"current_podcast": None,
"podcasts_processed": 0,
"total_podcasts": 0,
}
# Initialize progress tracking in database (works across processes)
activity_manager.start_background_task(
task_id="tmdb_sync",
task_type="tmdb_sync",
display_name="TMDB Sync",
status="Starting",
extra_data=sync_extra_data
)
try:
# Get TMDb, Podchaser, and Taddy config and notification settings
with db.get_connection() as conn:
cursor = conn.cursor()
cursor.execute('''
SELECT tmdb_api_key, tmdb_enabled, notify_new_appearances,
podchaser_api_key, podchaser_enabled, sync_past_movies,
podchaser_client_id, podchaser_client_secret,
taddy_user_id, taddy_api_key, taddy_enabled,
taddy_lookback_days, taddy_max_results,
taddy_user_id_2, taddy_api_key_2,
plex_url, plex_token, plex_sync_enabled
FROM appearance_config WHERE id = 1
''')
row = cursor.fetchone()
if not row:
logger.error("Appearance config not found")
return
(tmdb_api_key, tmdb_enabled, notify_enabled, podchaser_api_key,
podchaser_enabled, sync_past_movies, podchaser_client_id, podchaser_client_secret,
taddy_user_id, taddy_api_key, taddy_enabled,
taddy_lookback_days, taddy_max_results,
taddy_user_id_2, taddy_api_key_2,
plex_url, plex_token, plex_sync_enabled) = row
# Use defaults if not set
taddy_lookback_days = taddy_lookback_days or 730
taddy_max_results = taddy_max_results or 250
# Check if at least one service is enabled
if not tmdb_enabled and not podchaser_enabled and not taddy_enabled and not plex_sync_enabled:
logger.info("All appearance tracking services disabled in config")
return
# Initialize Pushover notifier if notifications enabled AND this is a scheduled sync
# Manual syncs from the web UI should NOT send push notifications
notifier = None
if notify_enabled and from_scheduler:
try:
settings_manager = SettingsManager(str(db.db_path))
config = settings_manager.get_all()
notifier = create_notifier_from_config(config, unified_db=db)
if notifier:
logger.info("Pushover notifier initialized for appearance notifications (scheduled sync)")
else:
logger.info("Pushover not configured or disabled, skipping notifications")
except Exception as e:
logger.warning(f"Failed to initialize Pushover notifier: {e}")
notifier = None
elif notify_enabled and not from_scheduler:
logger.debug("Skipping notifications for manual sync")
# Initialize API clients
tmdb = TMDbClient(tmdb_api_key) if tmdb_enabled and tmdb_api_key else None
# Initialize Podchaser client - prefer client credentials (OAuth2) over api_key
podchaser = None
if podchaser_enabled:
if podchaser_client_id and podchaser_client_secret:
try:
podchaser = await PodchaserClient.from_client_credentials(
podchaser_client_id, podchaser_client_secret
)
logger.info("Podchaser client initialized with OAuth2 client credentials")
except Exception as e:
logger.error(f"Failed to initialize Podchaser client: {e}")
elif podchaser_api_key:
podchaser = PodchaserClient(podchaser_api_key)
logger.info("Podchaser client initialized with API key")
# Initialize Taddy client with optional fallback account
taddy = None
if taddy_enabled and taddy_user_id and taddy_api_key:
taddy = TaddyClient(
taddy_user_id, taddy_api_key,
user_id_2=taddy_user_id_2, api_key_2=taddy_api_key_2
)
if taddy.has_fallback:
logger.info("Taddy client initialized with fallback account")
else:
logger.info("Taddy client initialized")
# Initialize Plex client for library-based discovery
plex = None
if plex_sync_enabled and plex_url and plex_token:
try:
plex = PlexClient(plex_url, plex_token)
# Test connection
if await plex.test_connection():
logger.info("Plex client initialized for appearance discovery")
else:
logger.warning("Plex connection failed - disabling Plex sync for this run")
plex = None
except Exception as e:
logger.error(f"Failed to initialize Plex client: {e}")
plex = None
# Get celebrities to sync
query = '''
SELECT id, name, tmdb_person_id, podchaser_creator_id
FROM celebrity_profiles
WHERE enabled = 1
'''
if celebrity_ids:
placeholders = ','.join('?' * len(celebrity_ids))
query += f' AND id IN ({placeholders})'
params = celebrity_ids
else:
params = []
with db.get_connection() as conn:
cursor = conn.cursor()
cursor.execute(query, params)
celebrities = cursor.fetchall()
logger.info(f"Syncing appearances for {len(celebrities)} celebrities (TMDb: {tmdb is not None}, Podchaser: {podchaser is not None}, Taddy: {taddy is not None}, Plex: {plex is not None})")
# Update total count for progress tracking
activity_manager.update_background_task(
"tmdb_sync", "Processing celebrities",
progress_current=0, progress_total=len(celebrities),
extra_data=sync_extra_data
)
# Track celebrities processed locally
celebrities_processed = 0
total_new_appearances = 0
# Crash recovery checkpoint
from modules.task_checkpoint import TaskCheckpoint
checkpoint = TaskCheckpoint('appearances:tmdb_sync', 'background')
checkpoint.start(total_items=len(celebrities))
if checkpoint.is_recovering():
logger.info("TMDb sync: recovering ā skipping already-synced celebrities")
# Process each celebrity
for celeb_id, celeb_name, tmdb_person_id, podchaser_creator_id in celebrities:
try:
if checkpoint.is_completed(str(celeb_id)):
celebrities_processed += 1
continue
checkpoint.set_current(str(celeb_id))
# Update progress
sync_extra_data["current_celebrity"] = celeb_name
activity_manager.update_background_task(
"tmdb_sync", f"Processing {celeb_name}",
progress_current=celebrities_processed, progress_total=len(celebrities),
extra_data=sync_extra_data
)
new_appearances = [] # Track all new appearances from all sources
# ===== TMDb Sync =====
if tmdb:
# Get or search for TMDb person ID
if not tmdb_person_id:
person = await tmdb.search_person(celeb_name)
if person:
tmdb_person_id = person["id"]
# Save person ID
with db.get_connection(for_write=True) as conn:
cursor = conn.cursor()
cursor.execute('''
UPDATE celebrity_profiles
SET tmdb_person_id = ?, tmdb_last_sync = CURRENT_TIMESTAMP
WHERE id = ?
''', (tmdb_person_id, celeb_id))
conn.commit()
else:
logger.warning(f"Could not find TMDb person for: {celeb_name}")
# Skip this celebrity for TMDb only
tmdb_person_id = None
# Find upcoming TV and movie appearances if we have TMDb ID
if tmdb_person_id:
# Get movies based on sync_past_movies setting
if sync_past_movies:
# Get COMPLETE filmography (all past and future movies AND TV)
logger.info(f"Syncing complete filmography (past + future) for {celeb_name}")
# Get all movies with credit types
sync_extra_data["phase"] = "fetching_movies"
activity_manager.update_background_task(
"tmdb_sync", f"Fetching movies for {celeb_name}",
progress_current=celebrities_processed, progress_total=len(celebrities),
extra_data=sync_extra_data
)
all_movies = await tmdb.find_all_movie_appearances(tmdb_person_id)
movie_appearances = [m for m in all_movies if m.get("status") == "upcoming"]
aired_movies = [m for m in all_movies if m.get("status") == "aired"]
# Get upcoming TV (detects next episode to air on any credited show)
sync_extra_data["phase"] = "fetching_tv"
activity_manager.update_background_task(
"tmdb_sync", f"Fetching TV for {celeb_name}",
progress_current=celebrities_processed, progress_total=len(celebrities),
extra_data=sync_extra_data
)
tv_appearances = await tmdb.find_upcoming_tv_appearances(tmdb_person_id)
# Progress callback for TV shows
def tv_progress_callback(current_show, shows_done, total):
sync_extra_data["current_show"] = current_show
sync_extra_data["shows_processed"] = shows_done
sync_extra_data["total_shows"] = total
activity_manager.update_background_task(
"tmdb_sync", f"Processing {current_show}",
progress_current=celebrities_processed, progress_total=len(celebrities),
extra_data=sync_extra_data
)
# Get historical/aired TV (episode-level for guests and regular cast)
all_tv = await tmdb.find_all_tv_appearances_with_credits(tmdb_person_id, celeb_name, tv_progress_callback)
aired_tv_appearances = [t for t in all_tv if t.get("status") == "aired"]
sync_extra_data["current_show"] = None # Clear after TV done
# Scan episode titles for shows where credits aren't always populated
# (e.g., Celebrity IOU, Who Do You Think You Are, etc.)
sync_extra_data["phase"] = "scanning_episode_titles"
activity_manager.update_background_task(
"tmdb_sync", f"Scanning episode titles for {celeb_name}",
progress_current=celebrities_processed, progress_total=len(celebrities),
extra_data=sync_extra_data
)
title_appearances = await tmdb.find_appearances_by_episode_title(celeb_name)
if title_appearances:
logger.info(f"Found {len(title_appearances)} episode title matches for {celeb_name}")
# Add to TV appearances (will be deduplicated by unique index)
tv_appearances.extend([t for t in title_appearances if t.get("status") == "upcoming"])
aired_tv_appearances.extend([t for t in title_appearances if t.get("status") == "aired"])
sync_extra_data["phase"] = "saving"
activity_manager.update_background_task(
"tmdb_sync", f"Saving appearances for {celeb_name}",
progress_current=celebrities_processed, progress_total=len(celebrities),
extra_data=sync_extra_data
)
else:
# Only get upcoming movies and TV
logger.info(f"Syncing upcoming only for {celeb_name}")
sync_extra_data["phase"] = "fetching"
activity_manager.update_background_task(
"tmdb_sync", f"Fetching upcoming for {celeb_name}",
progress_current=celebrities_processed, progress_total=len(celebrities),
extra_data=sync_extra_data
)
tv_appearances = await tmdb.find_upcoming_tv_appearances(tmdb_person_id)
upcoming_only = await tmdb.find_upcoming_movie_appearances(tmdb_person_id)
movie_appearances = upcoming_only
aired_movies = []
aired_tv_appearances = []
# Scan episode titles for upcoming shows
sync_extra_data["phase"] = "scanning_episode_titles"
activity_manager.update_background_task(
"tmdb_sync", f"Scanning episode titles for {celeb_name}",
progress_current=celebrities_processed, progress_total=len(celebrities),
extra_data=sync_extra_data
)
title_appearances = await tmdb.find_appearances_by_episode_title(celeb_name, lookback_days=7, lookahead_days=90)
if title_appearances:
logger.info(f"Found {len(title_appearances)} episode title matches for {celeb_name}")
tv_appearances.extend([t for t in title_appearances if t.get("status") == "upcoming"])
sync_extra_data["phase"] = "saving"
activity_manager.update_background_task(
"tmdb_sync", f"Saving appearances for {celeb_name}",
progress_current=celebrities_processed, progress_total=len(celebrities),
extra_data=sync_extra_data
)
else:
tv_appearances = []
movie_appearances = []
aired_movies = []
aired_tv_appearances = []
# Insert/update TMDb appearances
with db.get_connection(for_write=True) as conn:
cursor = conn.cursor()
# Process TV appearances
for app in tv_appearances:
# Get credit info (new fields, default to 'acting' for cast credits)
credit_type = app.get("credit_type", "acting")
character_name = app.get("character_name")
job_title = app.get("job_title")
# Check if this appearance already exists
cursor.execute('''
SELECT id FROM celebrity_appearances
WHERE celebrity_id = ?
AND appearance_type = 'TV'
AND tmdb_show_id = ?
AND season_number = ?
AND episode_number = ?
AND credit_type = ?
''', (celeb_id, app["tmdb_show_id"], app["season_number"], app["episode_number"], credit_type))
existing = cursor.fetchone()
is_new = existing is None
# Insert or update the appearance
cursor.execute('''
INSERT INTO celebrity_appearances (
celebrity_id, celebrity_name, appearance_type,
show_name, episode_title, network,
appearance_date, tmdb_show_id, season_number,
episode_number, tmdb_episode_id, description,
poster_url, announcement_date, credit_type,
character_name, job_title
) VALUES (?, ?, 'TV', ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, CURRENT_TIMESTAMP, ?, ?, ?)
ON CONFLICT(celebrity_id, appearance_type, tmdb_show_id, season_number, episode_number, credit_type) WHERE appearance_type = 'TV'
DO UPDATE SET
episode_title = excluded.episode_title,
appearance_date = excluded.appearance_date,
description = excluded.description,
poster_url = excluded.poster_url,
character_name = excluded.character_name,
job_title = excluded.job_title,
updated_at = CURRENT_TIMESTAMP
''', (
celeb_id, celeb_name, app["show_name"],
app["episode_title"], app["network"], app["appearance_date"],
app["tmdb_show_id"], app["season_number"], app["episode_number"],
app["tmdb_episode_id"], app["description"], app.get("poster_url"),
credit_type, character_name, job_title
))
# Track new appearances for notification
if is_new:
new_appearances.append({
**app,
"appearance_type": "TV"
})
# Process aired TV appearances (historical data)
for app in aired_tv_appearances:
# Get credit info (new fields, default to 'acting' for cast credits)
credit_type = app.get("credit_type", "acting")
character_name = app.get("character_name")
job_title = app.get("job_title")
# Check if this appearance already exists
cursor.execute('''
SELECT id FROM celebrity_appearances
WHERE celebrity_id = ?
AND appearance_type = 'TV'
AND tmdb_show_id = ?
AND season_number = ?
AND episode_number = ?
AND credit_type = ?
''', (celeb_id, app["tmdb_show_id"], app["season_number"], app["episode_number"], credit_type))
existing = cursor.fetchone()
# Insert or update the appearance with status='aired'
cursor.execute('''
INSERT INTO celebrity_appearances (
celebrity_id, celebrity_name, appearance_type,
show_name, episode_title, network,
appearance_date, tmdb_show_id, season_number,
episode_number, tmdb_episode_id, description,
poster_url, status, announcement_date, credit_type,
character_name, job_title
) VALUES (?, ?, 'TV', ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 'aired', CURRENT_TIMESTAMP, ?, ?, ?)
ON CONFLICT(celebrity_id, appearance_type, tmdb_show_id, season_number, episode_number, credit_type) WHERE appearance_type = 'TV'
DO UPDATE SET
episode_title = excluded.episode_title,
appearance_date = excluded.appearance_date,
description = excluded.description,
poster_url = excluded.poster_url,
character_name = excluded.character_name,
job_title = excluded.job_title,
status = 'aired',
updated_at = CURRENT_TIMESTAMP
''', (
celeb_id, celeb_name, app["show_name"],
app["episode_title"], app["network"], app["appearance_date"],
app["tmdb_show_id"], app["season_number"], app["episode_number"],
app["tmdb_episode_id"], app["description"], app.get("poster_url"),
credit_type, character_name, job_title
))
# Don't notify for historical appearances (only notify for new upcoming ones)
# Process movie appearances
for movie in movie_appearances:
# Get credit info (new fields, default to 'acting' for cast credits)
credit_type = movie.get("credit_type", "acting")
character_name = movie.get("character_name")
job_title = movie.get("job_title")
# Check if this movie already exists
cursor.execute('''
SELECT id FROM celebrity_appearances
WHERE celebrity_id = ?
AND appearance_type = 'Movie'
AND tmdb_show_id = ?
AND credit_type = ?
''', (celeb_id, movie["tmdb_movie_id"], credit_type))
existing = cursor.fetchone()
is_new = existing is None
# Insert or update the movie appearance
# Use partial index for movies (celebrity_id, appearance_type, tmdb_show_id, credit_type)
cursor.execute('''
INSERT INTO celebrity_appearances (
celebrity_id, celebrity_name, appearance_type,
show_name, network,
appearance_date, tmdb_show_id, description,
poster_url, announcement_date, credit_type,
character_name, job_title
) VALUES (?, ?, 'Movie', ?, ?, ?, ?, ?, ?, CURRENT_TIMESTAMP, ?, ?, ?)
ON CONFLICT(celebrity_id, appearance_type, tmdb_show_id, credit_type) WHERE appearance_type = 'Movie'
DO UPDATE SET
show_name = excluded.show_name,
appearance_date = excluded.appearance_date,
description = excluded.description,
poster_url = excluded.poster_url,
character_name = excluded.character_name,
job_title = excluded.job_title,
updated_at = CURRENT_TIMESTAMP
''', (
celeb_id, celeb_name, movie["movie_name"],
movie["studio"], movie["release_date"],
movie["tmdb_movie_id"], movie["description"],
movie.get("poster_url"), credit_type, character_name, job_title
))
# Track new movie appearances for notification
if is_new:
new_appearances.append({
**movie,
"appearance_type": "Movie",
"show_name": movie["movie_name"] # Add for notification compatibility
})
# Process aired movie appearances (historical filmography)
for movie in aired_movies:
# Get credit info (new fields, default to 'acting' for cast credits)
credit_type = movie.get("credit_type", "acting")
character_name = movie.get("character_name")
job_title = movie.get("job_title")
# Insert or update the aired movie
cursor.execute('''
INSERT INTO celebrity_appearances (
celebrity_id, celebrity_name, appearance_type,
show_name, network,
appearance_date, tmdb_show_id, description,
poster_url, status, announcement_date, credit_type,
character_name, job_title
) VALUES (?, ?, 'Movie', ?, ?, ?, ?, ?, ?, 'aired', CURRENT_TIMESTAMP, ?, ?, ?)
ON CONFLICT(celebrity_id, appearance_type, tmdb_show_id, credit_type) WHERE appearance_type = 'Movie'
DO UPDATE SET
show_name = excluded.show_name,
appearance_date = excluded.appearance_date,
description = excluded.description,
poster_url = excluded.poster_url,
character_name = excluded.character_name,
job_title = excluded.job_title,
status = 'aired',
updated_at = CURRENT_TIMESTAMP
''', (
celeb_id, celeb_name, movie["movie_name"],
movie["studio"], movie["release_date"],
movie["tmdb_movie_id"], movie["description"],
movie.get("poster_url"), credit_type, character_name, job_title
))
# Don't notify for historical movies
conn.commit()
total_count = len(tv_appearances) + len(movie_appearances) + len(aired_movies)
logger.info(f"Synced {total_count} TMDb appearances for {celeb_name} ({len(tv_appearances)} upcoming TV, {len(movie_appearances)} upcoming movies, {len(aired_movies)} aired movies)")
# ===== Podchaser Sync =====
if podchaser:
sync_extra_data["phase"] = "fetching_podcasts"
activity_manager.update_background_task(
"tmdb_sync", f"Fetching podcasts for {celeb_name}",
progress_current=celebrities_processed, progress_total=len(celebrities),
extra_data=sync_extra_data
)
# Get or search for Podchaser creator ID
if not podchaser_creator_id:
creator = await podchaser.search_creator(celeb_name)
if creator:
podchaser_creator_id = creator["pcid"]
# Save creator ID
with db.get_connection(for_write=True) as conn:
cursor = conn.cursor()
cursor.execute('''
UPDATE celebrity_profiles
SET podchaser_creator_id = ?, podchaser_last_sync = CURRENT_TIMESTAMP
WHERE id = ?
''', (podchaser_creator_id, celeb_id))
conn.commit()
else:
logger.warning(f"Could not find Podchaser creator for: {celeb_name}")
podchaser_creator_id = None
# Find upcoming podcast guest appearances if we have creator ID
if podchaser_creator_id:
podcast_appearances = await podchaser.find_upcoming_podcast_appearances(
podchaser_creator_id,
creator_name=celeb_name
)
else:
podcast_appearances = []
# Insert/update podcast appearances
if podcast_appearances:
sync_extra_data["total_podcasts"] = len(podcast_appearances)
sync_extra_data["podcasts_processed"] = 0
with db.get_connection(for_write=True) as conn:
cursor = conn.cursor()
for idx, podcast in enumerate(podcast_appearances):
sync_extra_data["current_podcast"] = podcast.get("podcast_name", "Unknown Podcast")
sync_extra_data["podcasts_processed"] = idx
activity_manager.update_background_task(
"tmdb_sync", f"Processing podcast {podcast.get('podcast_name', 'Unknown')}",
progress_current=celebrities_processed, progress_total=len(celebrities),
extra_data=sync_extra_data
)
# Check if this podcast episode already exists
cursor.execute('''
SELECT id FROM celebrity_appearances
WHERE celebrity_id = ?
AND appearance_type = 'Podcast'
AND tmdb_show_id = ?
''', (celeb_id, podcast["podchaser_episode_id"]))
existing = cursor.fetchone()
is_new = existing is None
# Insert or update the podcast appearance
# Using tmdb_show_id column to store podchaser_episode_id for consistency
cursor.execute('''
INSERT INTO celebrity_appearances (
celebrity_id, celebrity_name, appearance_type,
show_name, episode_title, network,
appearance_date, tmdb_show_id, description,
poster_url, url, audio_url, announcement_date
) VALUES (?, ?, 'Podcast', ?, ?, ?, ?, ?, ?, ?, ?, ?, CURRENT_TIMESTAMP)
ON CONFLICT(celebrity_id, appearance_type, tmdb_show_id) WHERE appearance_type = 'Podcast'
DO UPDATE SET
episode_title = excluded.episode_title,
show_name = excluded.show_name,
appearance_date = excluded.appearance_date,
description = excluded.description,
poster_url = excluded.poster_url,
url = excluded.url,
audio_url = excluded.audio_url,
updated_at = CURRENT_TIMESTAMP
''', (
celeb_id, celeb_name, podcast["podcast_name"],
podcast["episode_title"], podcast.get("role"), podcast["air_date"],
podcast["podchaser_episode_id"], podcast.get("description"),
podcast.get("poster_url"), podcast.get("episode_url"), podcast.get("audio_url")
))
# Track new podcast appearances for notification
if is_new:
new_appearances.append({
**podcast,
"appearance_type": "Podcast",
"show_name": podcast["podcast_name"],
"appearance_date": podcast["air_date"]
})
conn.commit()
sync_extra_data["podcasts_processed"] = len(podcast_appearances)
logger.info(f"Synced {len(podcast_appearances)} Podchaser podcast appearances for {celeb_name}")
# Backfill missing audio URLs from RSS feeds for Omny.fm podcasts
await backfill_audio_urls_from_rss(celeb_id, db)
# Clear podcast progress after Podchaser sync
sync_extra_data["current_podcast"] = None
# ===== Taddy Sync =====
if taddy:
sync_extra_data["phase"] = "fetching_podcasts_taddy"
activity_manager.update_background_task(
"tmdb_sync", f"Fetching Taddy podcasts for {celeb_name}",
progress_current=celebrities_processed, progress_total=len(celebrities),
extra_data=sync_extra_data
)
try:
# Search for podcast appearances by celebrity name
# Calculate max_pages from max_results (25 per page)
max_pages = (taddy_max_results + 24) // 25
taddy_appearances = await taddy.search_podcast_appearances(
celeb_name,
lookback_days=taddy_lookback_days,
lookahead_days=30,
max_pages=max_pages
)
if taddy_appearances:
sync_extra_data["total_podcasts"] = len(taddy_appearances)
sync_extra_data["podcasts_processed"] = 0
with db.get_connection(for_write=True) as conn:
cursor = conn.cursor()
for idx, podcast in enumerate(taddy_appearances):
sync_extra_data["current_podcast"] = podcast.get("show_name", "Unknown Podcast")
sync_extra_data["podcasts_processed"] = idx
activity_manager.update_background_task(
"tmdb_sync", f"Processing Taddy podcast {podcast.get('show_name', 'Unknown')}",
progress_current=celebrities_processed, progress_total=len(celebrities),
extra_data=sync_extra_data
)
# Use taddy_episode_uuid as unique identifier
taddy_uuid = podcast.get("taddy_episode_uuid")
if not taddy_uuid:
continue
# Check if this podcast episode already exists (by episode title + show name as fallback)
cursor.execute('''
SELECT id FROM celebrity_appearances
WHERE celebrity_id = ?
AND appearance_type = 'Podcast'
AND show_name = ?
AND episode_title = ?
''', (celeb_id, podcast["show_name"], podcast["episode_title"]))
existing = cursor.fetchone()
is_new = existing is None
if is_new:
# Insert new podcast appearance
cursor.execute('''
INSERT INTO celebrity_appearances (
celebrity_id, celebrity_name, appearance_type,
show_name, episode_title, appearance_date,
description, poster_url, audio_url, url, status,
credit_type, character_name, announcement_date
) VALUES (?, ?, 'Podcast', ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, CURRENT_TIMESTAMP)
''', (
celeb_id, celeb_name, podcast["show_name"],
podcast["episode_title"], podcast["appearance_date"],
podcast.get("description"), podcast.get("poster_url"),
podcast.get("audio_url"), podcast.get("url"),
podcast.get("status", "aired"),
podcast.get("credit_type", "guest"), podcast.get("character_name", "Self")
))
# Track new podcast appearances for notification
new_appearances.append({
**podcast,
"appearance_type": "Podcast"
})
conn.commit()
sync_extra_data["podcasts_processed"] = len(taddy_appearances)
logger.info(f"Synced {len(taddy_appearances)} Taddy podcast appearances for {celeb_name}")
except Exception as e:
logger.error(f"Taddy sync error for {celeb_name}: {e}")
# Clear podcast progress after Taddy sync
sync_extra_data["current_podcast"] = None
# ===== Plex Library Sync =====
# Discover movies/TV shows featuring this celebrity from Plex library
# For TV shows: matches at EPISODE level (only episodes in Plex get plex_rating_key)
# For Movies: matches the movie entry
if plex:
sync_extra_data["phase"] = "fetching_plex"
activity_manager.update_background_task(
"tmdb_sync", f"Scanning Plex library for {celeb_name}",
progress_current=celebrities_processed, progress_total=len(celebrities),
extra_data=sync_extra_data
)
# Helper to normalize show names for fuzzy matching
def normalize_show_name(name: str) -> str:
"""Strip country codes and years for matching, but keep subtitle after colon"""
if not name:
return ""
# Remove (US), (UK), (AU), etc.
normalized = re.sub(r'\s*\([A-Z]{2}\)\s*$', '', name)
# Remove year in parentheses at end
normalized = re.sub(r'\s*\(\d{4}\)\s*$', '', normalized)
# Don't strip colon parts - they're often meaningful (e.g., "Searching for Mexico")
return normalized.strip()
try:
plex_appearances = await plex.search_by_actor(celeb_name)
if plex_appearances:
plex_episodes_updated = 0
plex_movies_updated = 0
with db.get_connection(for_write=True) as conn:
cursor = conn.cursor()
for app in plex_appearances:
plex_show_key = app.get("plex_rating_key")
if not plex_show_key:
continue
show_name = app.get("show_name")
appearance_type = app.get("appearance_type", "Movie")
plex_library_id = app.get("plex_library_id")
normalized_plex = normalize_show_name(show_name)
if appearance_type == "TV":
# ===== TV SHOWS: Episode-level matching =====
# Get all episodes from Plex for this show
plex_episodes = await plex.get_all_episodes(plex_show_key)
if not plex_episodes:
logger.debug(f"No episodes found in Plex for '{show_name}'")
continue
# Get all TMDb episodes for this show (exact or normalized match only)
cursor.execute('''
SELECT id, season_number, episode_number
FROM celebrity_appearances
WHERE celebrity_id = ?
AND appearance_type = 'TV'
AND (show_name = ? OR show_name = ?)
AND season_number IS NOT NULL
AND episode_number IS NOT NULL
AND plex_rating_key IS NULL
''', (celeb_id, show_name, normalized_plex))
tmdb_episodes = cursor.fetchall()
# Match each TMDb episode to Plex episode
for row in tmdb_episodes:
app_id, season, episode = row
plex_ep = plex_episodes.get((season, episode))
if plex_ep:
# Episode exists in Plex - update with episode-specific rating key
cursor.execute('''
UPDATE celebrity_appearances
SET plex_rating_key = ?,
plex_show_rating_key = ?,
plex_library_id = ?,
updated_at = CURRENT_TIMESTAMP
WHERE id = ?
''', (plex_ep['ratingKey'], plex_show_key, plex_library_id, app_id))
plex_episodes_updated += 1
logger.debug(f"Matched {plex_episodes_updated} episodes for '{show_name}' "
f"(Plex has {len(plex_episodes)} eps, TMDb has {len(tmdb_episodes)} eps)")
else:
# ===== MOVIES: Direct matching =====
# Check if already linked
cursor.execute('''
SELECT id FROM celebrity_appearances
WHERE celebrity_id = ? AND plex_rating_key = ?
''', (celeb_id, plex_show_key))
if cursor.fetchone():
continue
# Try exact match
cursor.execute('''
UPDATE celebrity_appearances
SET plex_rating_key = ?,
plex_library_id = ?,
updated_at = CURRENT_TIMESTAMP
WHERE celebrity_id = ?
AND appearance_type = 'Movie'
AND show_name = ?
AND plex_rating_key IS NULL
''', (plex_show_key, plex_library_id, celeb_id, show_name))
if cursor.rowcount > 0:
plex_movies_updated += cursor.rowcount
continue
# Try normalized match (exact normalized name only)
if normalized_plex and normalized_plex != show_name:
cursor.execute('''
UPDATE celebrity_appearances
SET plex_rating_key = ?,
plex_library_id = ?,
updated_at = CURRENT_TIMESTAMP
WHERE celebrity_id = ?
AND appearance_type = 'Movie'
AND plex_rating_key IS NULL
AND show_name = ?
''', (plex_show_key, plex_library_id, celeb_id, normalized_plex))
if cursor.rowcount > 0:
plex_movies_updated += cursor.rowcount
continue
conn.commit()
logger.info(f"Plex sync for {celeb_name}: {plex_episodes_updated} episodes, "
f"{plex_movies_updated} movies updated (matching only, no new entries)")
except Exception as e:
logger.error(f"Plex sync error for {celeb_name}: {e}")
# Send notifications for all newly discovered appearances
if notifier and new_appearances:
for app in new_appearances:
try:
send_appearance_notification(notifier, celeb_name, app, db)
logger.info(f"Sent notification for new appearance: {celeb_name} on {app.get('show_name')}")
except Exception as e:
logger.error(f"Failed to send notification for {celeb_name} appearance: {e}")
# Rate limiting
await asyncio.sleep(1)
# Update progress after successful sync
celebrities_processed += 1
total_new_appearances += len(new_appearances)
sync_extra_data["new_appearances"] = total_new_appearances
activity_manager.update_background_task(
"tmdb_sync", f"Completed {celeb_name}",
progress_current=celebrities_processed, progress_total=len(celebrities),
extra_data=sync_extra_data
)
checkpoint.mark_completed(str(celeb_id))
except Exception as e:
logger.error(f"Error syncing {celeb_name}: {e}")
celebrities_processed += 1
activity_manager.update_background_task(
"tmdb_sync", f"Error syncing {celeb_name}",
progress_current=celebrities_processed, progress_total=len(celebrities),
extra_data=sync_extra_data
)
checkpoint.mark_completed(str(celeb_id))
continue
# Checkpoint complete
checkpoint.finish()
# Update status of past appearances to 'aired'
update_past_appearances_status(db)
# Pre-cache posters for appearances without cached data
await cache_uncached_posters(db)
# Update last check time for enabled services
with db.get_connection(for_write=True) as conn:
cursor = conn.cursor()
updates = []
if tmdb:
updates.append("tmdb_last_check = CURRENT_TIMESTAMP")
if podchaser:
updates.append("podchaser_last_check = CURRENT_TIMESTAMP")
if taddy:
updates.append("taddy_last_check = CURRENT_TIMESTAMP")
if plex:
updates.append("plex_last_check = CURRENT_TIMESTAMP")
if updates:
query = f"UPDATE appearance_config SET {', '.join(updates)} WHERE id = 1"
cursor.execute(query)
conn.commit()
services = []
if tmdb:
services.append("TMDb")
if podchaser:
services.append("Podchaser")
if taddy:
services.append("Taddy")
if plex:
services.append("Plex")
logger.info(f"Appearance sync completed for: {', '.join(services)}")
# Mark sync as complete
activity_manager.stop_background_task("tmdb_sync")
except Exception as e:
logger.error(f"Fatal error in sync_tmdb_appearances: {e}")
activity_manager.stop_background_task("tmdb_sync")
# ============================================================================
# PLEX INTEGRATION ENDPOINTS
# ============================================================================
# Plex OAuth state (in-memory for simplicity, could use Redis for production)
plex_oauth_state: Dict[int, Dict] = {}
class PlexConfigRequest(BaseModel):
plex_url: str
plex_token: str
class PlexServerSelectRequest(BaseModel):
server_url: str
server_token: str
server_name: str
machine_identifier: str
@router.post("/plex/auth/start")
async def start_plex_auth(
current_user: Dict = Depends(get_current_user)
):
"""
Start Plex OAuth flow. Returns a PIN and auth URL.
User should be redirected to the auth_url to authenticate.
"""
try:
oauth = PlexOAuth()
pin_data = await oauth.create_pin()
if not pin_data:
raise HTTPException(status_code=500, detail="Failed to create Plex authentication PIN")
# Store PIN for later verification
plex_oauth_state[pin_data['id']] = {
'code': pin_data['code'],
'created_at': datetime.now().isoformat(),
}
return {
"success": True,
"pin_id": pin_data['id'],
"auth_url": pin_data['auth_url'],
"expires_at": pin_data['expires_at'],
"message": "Open the auth_url in a new tab to sign in to Plex"
}
except HTTPException:
raise
except Exception as e:
logger.error(f"Error starting Plex auth: {e}")
raise HTTPException(status_code=500, detail=str(e))
@router.get("/plex/auth/check/{pin_id}")
async def check_plex_auth(
pin_id: int,
current_user: Dict = Depends(get_current_user)
):
"""
Check if Plex authentication is complete.
Returns the auth token and available servers if successful.
"""
try:
if pin_id not in plex_oauth_state:
raise HTTPException(status_code=404, detail="PIN not found or expired")
oauth = PlexOAuth()
token = await oauth.check_pin(pin_id)
if not token:
return {
"success": False,
"authenticated": False,
"message": "Waiting for authentication..."
}
# Authentication successful - get user info and servers
user_info = await oauth.get_user_info(token)
servers = await oauth.get_user_servers(token)
# Clean up the stored PIN
del plex_oauth_state[pin_id]
return {
"success": True,
"authenticated": True,
"token": token,
"user": user_info,
"servers": servers,
"message": f"Authenticated as {user_info.get('username', 'Unknown')}"
}
except HTTPException:
raise
except Exception as e:
logger.error(f"Error checking Plex auth: {e}")
raise HTTPException(status_code=500, detail=str(e))
@router.post("/plex/auth/save")
async def save_plex_auth(
config: PlexServerSelectRequest,
current_user: Dict = Depends(get_current_user),
db: UnifiedDatabase = Depends(get_db)
):
"""
Save the selected Plex server configuration after OAuth.
"""
try:
with db.get_connection(for_write=True) as conn:
cursor = conn.cursor()
cursor.execute('''
UPDATE appearance_config
SET plex_url = ?, plex_token = ?, updated_at = CURRENT_TIMESTAMP
WHERE id = 1
''', (config.server_url, config.server_token))
conn.commit()
# Test the connection (optional - OAuth already validated the token)
plex = PlexClient(config.server_url, config.server_token)
is_connected = await plex.test_connection()
if is_connected:
return {
"success": True,
"message": f"Connected to {config.server_name}",
"server_name": config.server_name,
"connection_verified": True
}
else:
# OAuth succeeded, so token is valid. Connection test may fail due to network issues
# (e.g., server running behind NAT, firewall, or using relay)
logger.warning(f"Plex connection test failed for {config.server_name}, but OAuth was successful. Config saved.")
return {
"success": True,
"message": f"Connected to {config.server_name} (direct connection unavailable, may use relay)",
"server_name": config.server_name,
"connection_verified": False
}
except Exception as e:
logger.error(f"Error saving Plex auth config: {e}")
raise HTTPException(status_code=500, detail=str(e))
@router.post("/plex/configure")
async def configure_plex(
config: PlexConfigRequest,
current_user: Dict = Depends(get_current_user),
db: UnifiedDatabase = Depends(get_db)
):
"""Save Plex connection settings"""
try:
with db.get_connection(for_write=True) as conn:
cursor = conn.cursor()
cursor.execute('''
UPDATE appearance_config
SET plex_url = ?, plex_token = ?, updated_at = CURRENT_TIMESTAMP
WHERE id = 1
''', (config.plex_url, config.plex_token))
conn.commit()
return {"success": True, "message": "Plex configuration saved"}
except Exception as e:
logger.error(f"Error saving Plex configuration: {e}")
raise HTTPException(status_code=500, detail=str(e))
@router.get("/plex/test")
async def test_plex_connection(
current_user: Dict = Depends(get_current_user),
db: UnifiedDatabase = Depends(get_db)
):
"""Test Plex connection"""
try:
with db.get_connection() as conn:
cursor = conn.cursor()
cursor.execute('SELECT plex_url, plex_token FROM appearance_config WHERE id = 1')
row = cursor.fetchone()
if not row or not row[0] or not row[1]:
return {"success": False, "message": "Plex not configured"}
plex_url, plex_token = row
plex = PlexClient(plex_url, plex_token)
is_connected = await plex.test_connection()
if is_connected:
server_info = await plex.get_server_identity()
return {
"success": True,
"message": f"Connected to {server_info.get('friendlyName', 'Plex Server')}",
"server_name": server_info.get('friendlyName'),
"version": server_info.get('version')
}
else:
return {"success": False, "message": "Failed to connect to Plex server"}
except Exception as e:
logger.error(f"Error testing Plex connection: {e}")
raise HTTPException(status_code=500, detail=str(e))
@router.get("/plex/libraries")
async def get_plex_libraries(
current_user: Dict = Depends(get_current_user),
db: UnifiedDatabase = Depends(get_db)
):
"""Get list of Plex libraries"""
try:
with db.get_connection() as conn:
cursor = conn.cursor()
cursor.execute('SELECT plex_url, plex_token FROM appearance_config WHERE id = 1')
row = cursor.fetchone()
if not row or not row[0] or not row[1]:
raise HTTPException(status_code=400, detail="Plex not configured")
plex_url, plex_token = row
plex = PlexClient(plex_url, plex_token)
libraries = await plex.get_libraries()
return {
"success": True,
"libraries": libraries
}
except HTTPException:
raise
except Exception as e:
logger.error(f"Error getting Plex libraries: {e}")
raise HTTPException(status_code=500, detail=str(e))
@router.post("/plex/match")
async def match_appearances_to_plex(
background_tasks: BackgroundTasks,
current_user: Dict = Depends(get_current_user),
db: UnifiedDatabase = Depends(get_db)
):
"""Match appearances to Plex library items (runs in background)"""
try:
with db.get_connection() as conn:
cursor = conn.cursor()
cursor.execute('SELECT plex_url, plex_token FROM appearance_config WHERE id = 1')
row = cursor.fetchone()
if not row or not row[0] or not row[1]:
raise HTTPException(status_code=400, detail="Plex not configured")
# Manual runs don't send notifications
background_tasks.add_task(match_plex_appearances_task, send_notifications=False)
return {
"success": True,
"message": "Plex matching started in background"
}
except HTTPException:
raise
except Exception as e:
logger.error(f"Error starting Plex matching: {e}")
raise HTTPException(status_code=500, detail=str(e))
async def match_plex_appearances_task(send_notifications: bool = True):
"""Background task to match appearances to Plex library"""
db = get_app_state().db
try:
# Get Plex config
with db.get_connection() as conn:
cursor = conn.cursor()
cursor.execute('SELECT plex_url, plex_token FROM appearance_config WHERE id = 1')
row = cursor.fetchone()
if not row or not row[0] or not row[1]:
logger.error("Plex not configured for matching")
return
plex_url, plex_token = row
plex = PlexClient(plex_url, plex_token)
# Get unmatched appearances OR TV shows missing show key (movies and TV shows)
with db.get_connection() as conn:
cursor = conn.cursor()
cursor.execute('''
SELECT id, appearance_type, show_name, tmdb_show_id, appearance_date,
season_number, episode_number
FROM celebrity_appearances
WHERE (plex_rating_key IS NULL
OR (appearance_type = 'TV' AND plex_show_rating_key IS NULL))
AND appearance_type IN ('Movie', 'TV')
ORDER BY appearance_date DESC
LIMIT 500
''')
rows = cursor.fetchall()
if not rows:
logger.info("No unmatched appearances to process")
return
appearances = []
for row in rows:
app = {
'id': row[0],
'appearance_type': row[1],
'show_name': row[2] if row[1] == 'TV' else None,
'movie_name': row[2] if row[1] == 'Movie' else None,
'tmdb_show_id': row[3] if row[1] == 'TV' else None,
'tmdb_movie_id': row[3] if row[1] == 'Movie' else None,
'release_date': row[4],
'season_number': row[5],
'episode_number': row[6],
}
appearances.append(app)
logger.info(f"Matching {len(appearances)} appearances to Plex library")
# Match to Plex with incremental saves for real-time updates
total_matched = 0
new_matches = [] # Track new matches for notifications
batch_size = 10 # Save every 10 matches
async def save_match(appearance_id: int, match_info: dict):
nonlocal total_matched
with db.get_connection(for_write=True) as conn:
cursor = conn.cursor()
# Check if this is a NEW match (not previously matched)
cursor.execute('SELECT plex_rating_key FROM celebrity_appearances WHERE id = ?', (appearance_id,))
existing = cursor.fetchone()
is_new_match = existing and existing[0] is None
cursor.execute('''
UPDATE celebrity_appearances
SET plex_rating_key = ?, plex_library_id = ?, plex_show_rating_key = ?, updated_at = CURRENT_TIMESTAMP
WHERE id = ?
''', (match_info['plex_rating_key'], match_info.get('plex_library_id'), match_info.get('plex_show_rating_key'), appearance_id))
conn.commit()
# If new match, get details for notification
# Only notify if we have an actual episode/movie key (not just show key)
# For TV shows, plex_rating_key is the episode key - if None, episode not in Plex
has_actual_match = match_info.get('plex_rating_key') is not None
if is_new_match and has_actual_match:
cursor.execute('''
SELECT cp.name, ca.show_name, ca.appearance_type, ca.appearance_date, ca.poster_url
FROM celebrity_appearances ca
JOIN celebrity_profiles cp ON ca.celebrity_id = cp.id
WHERE ca.id = ?
''', (appearance_id,))
match_details = cursor.fetchone()
if match_details:
new_matches.append({
'appearance_id': appearance_id,
'celebrity_name': match_details[0],
'show_name': match_details[1],
'appearance_type': match_details[2],
'appearance_date': match_details[3],
'poster_url': match_details[4]
})
total_matched += 1
if total_matched % batch_size == 0:
logger.info(f"Plex matching progress: {total_matched} matched so far")
matches = await plex.batch_match_appearances(appearances, on_match=save_match)
logger.info(f"Matched {total_matched} appearances to Plex library")
# Send notifications for new matches (limit to 5 to avoid spam)
# Only send notifications for scheduled runs, not manual runs
if new_matches and send_notifications:
# Check if Plex match notifications are enabled
with db.get_connection() as conn:
cursor = conn.cursor()
cursor.execute('SELECT notify_plex_matches, notify_include_poster FROM appearance_config WHERE id = 1')
notify_config = cursor.fetchone()
plex_notify_enabled = notify_config[0] if notify_config and notify_config[0] is not None else True
include_poster = notify_config[1] if notify_config and notify_config[1] is not None else True
if plex_notify_enabled:
logger.info(f"Sending notifications for {len(new_matches)} new Plex matches")
notifications_sent = 0
for match in new_matches[:5]: # Limit to 5 notifications
await send_plex_match_notification(
celebrity_name=match['celebrity_name'],
show_name=match['show_name'],
appearance_type=match['appearance_type'],
appearance_date=match['appearance_date'],
appearance_id=match['appearance_id'],
poster_url=match.get('poster_url') if include_poster else None,
db=db
)
notifications_sent += 1
if len(new_matches) > 5:
logger.info(f"Skipped {len(new_matches) - 5} additional match notifications to avoid spam")
else:
logger.info(f"Plex match notifications disabled, skipping {len(new_matches)} matches")
except Exception as e:
logger.error(f"Error in Plex matching task: {e}")
@router.get("/plex/stats")
async def get_plex_match_stats(
current_user: Dict = Depends(get_current_user),
db: UnifiedDatabase = Depends(get_db)
):
"""Get Plex matching statistics"""
try:
with db.get_connection() as conn:
cursor = conn.cursor()
# Get total matchable appearances (Movies and TV only)
cursor.execute('''
SELECT COUNT(*) FROM celebrity_appearances
WHERE appearance_type IN ('Movie', 'TV')
''')
total = cursor.fetchone()[0]
# Get matched count
cursor.execute('''
SELECT COUNT(*) FROM celebrity_appearances
WHERE plex_rating_key IS NOT NULL
AND appearance_type IN ('Movie', 'TV')
''')
matched = cursor.fetchone()[0]
# Get breakdown by type
cursor.execute('''
SELECT appearance_type,
COUNT(*) as total,
SUM(CASE WHEN plex_rating_key IS NOT NULL THEN 1 ELSE 0 END) as matched
FROM celebrity_appearances
WHERE appearance_type IN ('Movie', 'TV')
GROUP BY appearance_type
''')
breakdown = {}
for row in cursor.fetchall():
breakdown[row[0]] = {'total': row[1], 'matched': row[2]}
return {
"total": total,
"matched": matched,
"unmatched": total - matched,
"percentage": round((matched / total * 100) if total > 0 else 0, 1),
"breakdown": breakdown
}
except Exception as e:
logger.error(f"Error getting Plex stats: {e}")
raise HTTPException(status_code=500, detail=str(e))
@router.get("/plex/watch-url/{appearance_id}")
async def get_plex_watch_url(
appearance_id: int,
current_user: Dict = Depends(get_current_user),
db: UnifiedDatabase = Depends(get_db)
):
"""Get Plex watch URL for an appearance"""
try:
with db.get_connection() as conn:
cursor = conn.cursor()
# Get appearance and Plex config
cursor.execute('''
SELECT a.plex_rating_key, c.plex_url, c.plex_token
FROM celebrity_appearances a, appearance_config c
WHERE a.id = ? AND c.id = 1
''', (appearance_id,))
row = cursor.fetchone()
if not row:
raise HTTPException(status_code=404, detail="Appearance not found")
rating_key, plex_url, plex_token = row
if not rating_key:
return {"success": False, "message": "Appearance not matched to Plex"}
if not plex_url:
return {"success": False, "message": "Plex not configured"}
plex = PlexClient(plex_url, plex_token)
server_info = await plex.get_server_identity()
if server_info:
watch_url = plex.get_full_watch_url(rating_key, server_info.get('machineIdentifier'))
else:
watch_url = plex.get_watch_url(rating_key)
return {
"success": True,
"watch_url": watch_url,
"rating_key": rating_key
}
except HTTPException:
raise
except Exception as e:
logger.error(f"Error getting Plex watch URL: {e}")
raise HTTPException(status_code=500, detail=str(e))
# ==================== HELPER FUNCTIONS FOR NOTIFICATIONS ====================
async def send_appearance_reminders(db: UnifiedDatabase = None) -> Dict:
"""
Check for upcoming appearances and send push notification reminders.
This function is called at midnight daily by the scheduler.
"""
if db is None:
db = get_app_state().db
try:
with db.get_connection(for_write=True) as conn:
cursor = conn.cursor()
# Get notification settings
cursor.execute('''
SELECT notify_new_appearances, notify_days_before, notify_include_poster
FROM appearance_config
WHERE id = 1
''')
config = cursor.fetchone()
if not config or not config[0]:
logger.info("Appearance notifications are disabled")
return {"success": True, "message": "Notifications disabled", "sent": 0}
notify_days_before = config[1] or 1
include_poster = config[2] if config[2] is not None else True
# Get Pushover config from SettingsManager
settings_manager = SettingsManager(str(db.db_path))
pushover_config = settings_manager.get('pushover', {})
if not pushover_config.get('enabled'):
logger.info("Pushover notifications disabled or not configured")
return {"success": True, "message": "Pushover disabled or not configured", "sent": 0}
if not pushover_config.get('user_key') or not pushover_config.get('api_token'):
logger.info("Pushover credentials not configured")
return {"success": True, "message": "Pushover credentials not configured", "sent": 0}
# Get appearances happening TODAY only (reminders sent at midnight)
# Only get appearances we haven't already sent reminders for
cursor.execute('''
SELECT DISTINCT
ca.id,
cp.name as celebrity_name,
ca.show_name,
ca.appearance_type,
ca.appearance_date,
ca.episode_title,
ca.network,
ca.poster_url
FROM celebrity_appearances ca
JOIN celebrity_profiles cp ON ca.celebrity_id = cp.id
LEFT JOIN appearance_notifications an ON (
an.appearance_id = ca.id
AND an.notification_type = 'reminder'
)
WHERE ca.status = 'upcoming'
AND ca.appearance_date = date('now')
AND an.id IS NULL
ORDER BY ca.appearance_date ASC
''')
upcoming = cursor.fetchall()
if not upcoming:
logger.info("No upcoming appearances to remind about")
return {"success": True, "message": "No upcoming appearances", "sent": 0}
# Create notifier
notifier = PushoverNotifier(
user_key=pushover_config.get('user_key'),
api_token=pushover_config.get('api_token'),
enabled=True,
default_priority=0,
include_image=pushover_config.get('include_image', True),
unified_db=db
)
sent_count = 0
for row in upcoming:
appearance_id, celebrity_name, show_name, appearance_type, appearance_date, episode_title, network, poster_url = row
# Format the message
date_obj = datetime.strptime(appearance_date, '%Y-%m-%d')
days_until = (date_obj.date() - datetime.now().date()).days
if days_until == 0:
time_str = "TODAY"
elif days_until == 1:
time_str = "TOMORROW"
else:
time_str = f"in {days_until} days"
title = f"š
{celebrity_name} Appearance {time_str}"
if appearance_type == 'TV':
if episode_title:
message = f"{show_name}: {episode_title}"
else:
message = show_name
if network:
message += f" on {network}"
elif appearance_type == 'Movie':
message = f"{show_name} (Movie)"
elif appearance_type == 'Podcast':
message = f"šļø {show_name}"
else:
message = show_name
message += f"\nš {date_obj.strftime('%B %d, %Y')}"
# Download poster image if available and enabled
poster_temp_path = None
if poster_url and include_poster:
poster_temp_path = await download_poster_image(poster_url)
# Send notification with poster image
try:
success = notifier.send_notification(
title=title,
message=message,
priority=0,
image_path=poster_temp_path
)
finally:
# Clean up temp poster file
if poster_temp_path and os.path.exists(poster_temp_path):
try:
os.unlink(poster_temp_path)
except Exception:
pass
if success:
sent_count += 1
# Record in database with full formatted message
full_message = f"š
{celebrity_name} Appearance {time_str}\n{message}"
cursor.execute('''
INSERT INTO appearance_notifications
(appearance_id, celebrity_name, show_name, appearance_type,
appearance_date, notification_type, message, poster_url,
is_sent, sent_at)
VALUES (?, ?, ?, ?, ?, 'reminder', ?, ?, 1, CURRENT_TIMESTAMP)
''', (appearance_id, celebrity_name, show_name, appearance_type,
appearance_date, full_message, poster_url))
conn.commit()
logger.info(f"Sent reminder for {celebrity_name} - {show_name} on {appearance_date}")
return {
"success": True,
"message": f"Sent {sent_count} reminders",
"sent": sent_count,
"total_upcoming": len(upcoming)
}
except Exception as e:
logger.error(f"Error sending appearance reminders: {e}")
import traceback
logger.error(traceback.format_exc())
return {"success": False, "error": str(e), "sent": 0}
async def send_plex_match_notification(
celebrity_name: str,
show_name: str,
appearance_type: str,
appearance_date: str,
appearance_id: int,
poster_url: Optional[str],
db: UnifiedDatabase
) -> bool:
"""Send push notification when a new Plex match is found"""
try:
# Get Pushover config from SettingsManager
settings_manager = SettingsManager(str(db.db_path))
pushover_config = settings_manager.get('pushover', {})
if not pushover_config.get('enabled'):
return False
if not pushover_config.get('user_key') or not pushover_config.get('api_token'):
return False
# Create notifier
notifier = PushoverNotifier(
user_key=pushover_config.get('user_key'),
api_token=pushover_config.get('api_token'),
enabled=True,
default_priority=-1, # Low priority for plex matches
include_image=True,
unified_db=db
)
with db.get_connection(for_write=True) as conn:
cursor = conn.cursor()
title = f"š¬ New Plex Match: {celebrity_name}"
message = f"{show_name} ({appearance_type})"
if appearance_date:
try:
date_obj = datetime.strptime(appearance_date[:10], '%Y-%m-%d')
message += f"\nš {date_obj.strftime('%B %d, %Y')}"
except ValueError:
logger.debug(f"Could not parse date: {appearance_date}")
message += "\nā
Available in Plex"
# Download poster image if available
poster_temp_path = None
if poster_url:
poster_temp_path = await download_poster_image(poster_url)
# Send notification with poster image
try:
success = notifier.send_notification(
title=title,
message=message,
priority=-1,
image_path=poster_temp_path
)
finally:
# Clean up temp poster file
if poster_temp_path and os.path.exists(poster_temp_path):
try:
os.unlink(poster_temp_path)
except Exception:
pass
if success:
# Record notification with full formatted message
full_message = f"š¬ New Plex Match: {celebrity_name}\n{message}"
cursor.execute('''
INSERT INTO appearance_notifications
(appearance_id, celebrity_name, show_name, appearance_type,
appearance_date, notification_type, message, poster_url,
is_sent, sent_at)
VALUES (?, ?, ?, ?, ?, 'plex_match', ?, ?, 1, CURRENT_TIMESTAMP)
''', (appearance_id, celebrity_name, show_name, appearance_type,
appearance_date[:10] if appearance_date else None,
full_message, poster_url))
conn.commit()
logger.info(f"Sent Plex match notification for {celebrity_name} - {show_name}")
return success
except Exception as e:
logger.error(f"Error sending Plex match notification: {e}")
return False