Bryan Van Deusen
230 lines
7.8 KiB
Python
230 lines
7.8 KiB
Python
"""Source management API endpoints."""
|
|
|
|
from quart import Blueprint, request, jsonify, current_app
|
|
from sqlalchemy import select, func
|
|
from sqlalchemy.ext.asyncio import AsyncSession
|
|
from sqlalchemy.orm import selectinload
|
|
|
|
from app.models.source import Source
|
|
from app.models.subscription import Subscription
|
|
from app.tasks.downloads import download_source
|
|
from app.api.settings import get_setting_value
|
|
|
|
bp = Blueprint("sources", __name__)
|
|
|
|
|
|
@bp.route("", methods=["GET"])
|
|
async def list_sources():
|
|
"""List all sources with optional filtering and pagination."""
|
|
# Query parameters
|
|
platform = request.args.get("platform")
|
|
subscription_id = request.args.get("subscription_id")
|
|
enabled = request.args.get("enabled")
|
|
page = int(request.args.get("page", 1))
|
|
per_page = min(int(request.args.get("per_page", 50)), 100)
|
|
|
|
async with current_app.db_engine.connect() as conn:
|
|
session = AsyncSession(bind=conn)
|
|
|
|
# Build query with subscription eager loading
|
|
query = select(Source).options(selectinload(Source.subscription))
|
|
|
|
if platform:
|
|
query = query.where(Source.platform == platform)
|
|
if subscription_id:
|
|
query = query.where(Source.subscription_id == int(subscription_id))
|
|
if enabled is not None:
|
|
query = query.where(Source.enabled == (enabled.lower() == "true"))
|
|
|
|
# Get total count
|
|
count_query = select(func.count()).select_from(Source)
|
|
if platform:
|
|
count_query = count_query.where(Source.platform == platform)
|
|
if subscription_id:
|
|
count_query = count_query.where(Source.subscription_id == int(subscription_id))
|
|
if enabled is not None:
|
|
count_query = count_query.where(Source.enabled == (enabled.lower() == "true"))
|
|
|
|
total_result = await session.execute(count_query)
|
|
total = total_result.scalar()
|
|
|
|
# Apply pagination - order by subscription name, then platform
|
|
query = query.join(Subscription).order_by(Subscription.name, Source.platform)
|
|
query = query.offset((page - 1) * per_page).limit(per_page)
|
|
|
|
result = await session.execute(query)
|
|
sources = result.scalars().all()
|
|
|
|
return jsonify({
|
|
"items": [s.to_dict() for s in sources],
|
|
"total": total,
|
|
"page": page,
|
|
"per_page": per_page,
|
|
"pages": (total + per_page - 1) // per_page if total > 0 else 0,
|
|
})
|
|
|
|
|
|
@bp.route("", methods=["POST"])
|
|
async def create_source():
|
|
"""Create a new source for a subscription."""
|
|
data = await request.get_json()
|
|
|
|
# Validate required fields
|
|
required = ["subscription_id", "platform", "url"]
|
|
missing = [f for f in required if not data.get(f)]
|
|
if missing:
|
|
return jsonify({"error": f"Missing required fields: {', '.join(missing)}"}), 400
|
|
|
|
# Validate platform
|
|
valid_platforms = ["patreon", "subscribestar", "hentaifoundry", "discord"]
|
|
if data["platform"] not in valid_platforms:
|
|
return jsonify({"error": f"Invalid platform. Must be one of: {', '.join(valid_platforms)}"}), 400
|
|
|
|
async with current_app.db_engine.connect() as conn:
|
|
session = AsyncSession(bind=conn)
|
|
|
|
# Check subscription exists
|
|
sub_result = await session.execute(
|
|
select(Subscription).where(Subscription.id == data["subscription_id"])
|
|
)
|
|
subscription = sub_result.scalar()
|
|
if not subscription:
|
|
return jsonify({"error": "Subscription not found"}), 404
|
|
|
|
# Check for duplicate platform+url
|
|
existing = await session.execute(
|
|
select(Source).where(
|
|
Source.platform == data["platform"],
|
|
Source.url == data["url"]
|
|
)
|
|
)
|
|
if existing.scalar():
|
|
return jsonify({"error": "Source with this platform and URL already exists"}), 409
|
|
|
|
# Get default check interval from database settings
|
|
default_interval = await get_setting_value(
|
|
session, "download.schedule_interval", 3600
|
|
)
|
|
|
|
source = Source(
|
|
subscription_id=data["subscription_id"],
|
|
platform=data["platform"],
|
|
url=data["url"],
|
|
enabled=data.get("enabled", True),
|
|
check_interval=data.get("check_interval", default_interval),
|
|
metadata_=data.get("metadata", {}),
|
|
)
|
|
|
|
session.add(source)
|
|
await session.commit()
|
|
await session.refresh(source)
|
|
|
|
current_app.logger.info(f"Created source: {subscription.name}/{source.platform}")
|
|
return jsonify(source.to_dict()), 201
|
|
|
|
|
|
@bp.route("/<int:source_id>", methods=["GET"])
|
|
async def get_source(source_id: int):
|
|
"""Get a single source by ID."""
|
|
async with current_app.db_engine.connect() as conn:
|
|
session = AsyncSession(bind=conn)
|
|
|
|
result = await session.execute(
|
|
select(Source)
|
|
.options(selectinload(Source.subscription))
|
|
.where(Source.id == source_id)
|
|
)
|
|
source = result.scalar()
|
|
|
|
if not source:
|
|
return jsonify({"error": "Source not found"}), 404
|
|
|
|
return jsonify(source.to_dict())
|
|
|
|
|
|
@bp.route("/<int:source_id>", methods=["PATCH"])
|
|
async def update_source(source_id: int):
|
|
"""Update a source."""
|
|
data = await request.get_json()
|
|
|
|
async with current_app.db_engine.connect() as conn:
|
|
session = AsyncSession(bind=conn)
|
|
|
|
result = await session.execute(
|
|
select(Source)
|
|
.options(selectinload(Source.subscription))
|
|
.where(Source.id == source_id)
|
|
)
|
|
source = result.scalar()
|
|
|
|
if not source:
|
|
return jsonify({"error": "Source not found"}), 404
|
|
|
|
# Update allowed fields
|
|
allowed_fields = ["enabled", "check_interval", "metadata"]
|
|
for field in allowed_fields:
|
|
if field in data:
|
|
if field == "metadata":
|
|
source.metadata_ = data[field]
|
|
else:
|
|
setattr(source, field, data[field])
|
|
|
|
await session.commit()
|
|
await session.refresh(source)
|
|
|
|
current_app.logger.info(f"Updated source: {source.subscription.name}/{source.platform}")
|
|
return jsonify(source.to_dict())
|
|
|
|
|
|
@bp.route("/<int:source_id>", methods=["DELETE"])
|
|
async def delete_source(source_id: int):
|
|
"""Delete a source."""
|
|
async with current_app.db_engine.connect() as conn:
|
|
session = AsyncSession(bind=conn)
|
|
|
|
result = await session.execute(
|
|
select(Source)
|
|
.options(selectinload(Source.subscription))
|
|
.where(Source.id == source_id)
|
|
)
|
|
source = result.scalar()
|
|
|
|
if not source:
|
|
return jsonify({"error": "Source not found"}), 404
|
|
|
|
info = f"{source.subscription.name}/{source.platform}"
|
|
await session.delete(source)
|
|
await session.commit()
|
|
|
|
current_app.logger.info(f"Deleted source: {info}")
|
|
return "", 204
|
|
|
|
|
|
@bp.route("/<int:source_id>/check", methods=["POST"])
|
|
async def trigger_check(source_id: int):
|
|
"""Trigger an immediate download check for a source."""
|
|
async with current_app.db_engine.connect() as conn:
|
|
session = AsyncSession(bind=conn)
|
|
|
|
result = await session.execute(
|
|
select(Source)
|
|
.options(selectinload(Source.subscription))
|
|
.where(Source.id == source_id)
|
|
)
|
|
source = result.scalar()
|
|
|
|
if not source:
|
|
return jsonify({"error": "Source not found"}), 404
|
|
|
|
# Queue Celery task for immediate download
|
|
task = download_source.delay(source_id)
|
|
|
|
current_app.logger.info(f"Triggered check for source: {source.subscription.name}/{source.platform}")
|
|
return jsonify({
|
|
"message": "Check queued",
|
|
"source_id": source_id,
|
|
"subscription_name": source.subscription.name,
|
|
"platform": source.platform,
|
|
"task_id": task.id,
|
|
}), 202
|