"""Job and queue route handlers.""" from __future__ import annotations from typing import Any from backend.routes.common import handle_request from backend.routes.params import int_or_default, optional_str from backend.services.event_stream_service import get_default_event_bus from backend.services.generation_job_retry_service import GenerationJobRetryService from backend.services.queue_service import QueueService from core.audit_service import AuditService from core.identity import RequestContext from core.security import require_authenticated, require_permission, require_task_retry, require_write from database.db_helper import Database, load_database_settings from database.repositories.job_repository import JobRepository def list_jobs( ctx: RequestContext, query: dict[str, Any] | None = None, service: QueueService | None = None, ) -> dict: queue_service = service or _create_queue_service() params = query or {} def action() -> dict[str, Any]: require_authenticated(ctx) result = queue_service.list_jobs( status=optional_str(params.get("status")), workflow_id=optional_str(params.get("workflow_id")), profile_id=optional_str(params.get("profile_id")), page=int_or_default(params.get("page"), 1), page_size=int_or_default(params.get("page_size"), 30), ).to_dict() if not ctx.has_permission("can_manage_materials"): visible = [item for item in result["items"] if item.get("metadata", {}).get("source") != "advanced_material"] result = {**result, "items": visible, "total": max(int(result.get("total") or 0) - (len(result["items"]) - len(visible)), 0)} return result return handle_request(ctx, action) def get_job( ctx: RequestContext, task_id: str, service: QueueService | None = None, ) -> dict: queue_service = service or _create_queue_service() def action() -> dict[str, Any]: require_authenticated(ctx) task = queue_service.get_job(task_id) if task.metadata.get("source") == "advanced_material": require_permission(ctx, "can_manage_materials") return task.to_dict() return handle_request(ctx, action) def delete_job( ctx: RequestContext, task_id: str, service: QueueService | None = None, ) -> dict: queue_service = service or _create_queue_service() def action() -> dict[str, Any]: require_task_retry(ctx) return queue_service.delete_job(task_id, ctx) return handle_request(ctx, action) def cancel_job( ctx: RequestContext, task_id: str, service: QueueService | None = None, ) -> dict: queue_service = service or _create_queue_service() def action() -> dict[str, Any]: require_write(ctx) task = queue_service.get_job(task_id) if task.metadata.get("source") == "advanced_material": require_permission(ctx, "can_manage_materials") from backend.services.advanced_material_service import create_advanced_material_service import_id = str(task.metadata.get("advanced_material_import_id") or "").strip() return create_advanced_material_service().cancel_import(import_id, ctx) return queue_service.cancel_job(task_id, ctx).to_dict() return handle_request(ctx, action) def retry_job( ctx: RequestContext, task_id: str, payload: dict[str, Any] | None = None, service: GenerationJobRetryService | None = None, ) -> dict: retry_service = service def action() -> dict[str, Any]: require_task_retry(ctx) queue_service = _create_queue_service() task = queue_service.get_job(task_id) if task.metadata.get("source") == "advanced_material": require_permission(ctx, "can_manage_materials") from backend.services.advanced_material_service import create_advanced_material_service import_id = str(task.metadata.get("advanced_material_import_id") or "").strip() return create_advanced_material_service().retry_import(import_id, ctx) resolved_retry_service = retry_service or _create_generation_job_retry_service() return resolved_retry_service.retry_job(task_id, ctx, overrides=payload or {}).to_dict() return handle_request(ctx, action) def retry_dead_letter_jobs( ctx: RequestContext, payload: dict[str, Any] | None = None, service: GenerationJobRetryService | None = None, ) -> dict: retry_service = service or _create_generation_job_retry_service() params = payload or {} def action() -> dict[str, Any]: require_task_retry(ctx) return retry_service.retry_dead_letters(ctx, limit=int_or_default(params.get("limit"), 5)) return handle_request(ctx, action) def move_failed_jobs_to_dead_letter( ctx: RequestContext, payload: dict[str, Any] | None = None, service: QueueService | None = None, ) -> dict: queue_service = service or _create_queue_service() params = payload or {} def action() -> dict[str, Any]: require_task_retry(ctx) return queue_service.move_failed_to_dead_letter(ctx, limit=int_or_default(params.get("limit"), 50)) return handle_request(ctx, action) def clear_failed_jobs( ctx: RequestContext, payload: dict[str, Any] | None = None, service: QueueService | None = None, ) -> dict: queue_service = service or _create_queue_service() params = payload or {} def action() -> dict[str, Any]: require_task_retry(ctx) return queue_service.clear_failed_jobs(ctx, limit=int_or_default(params.get("limit"), 100)) return handle_request(ctx, action) def clear_terminal_jobs( ctx: RequestContext, payload: dict[str, Any] | None = None, service: QueueService | None = None, ) -> dict: queue_service = service or _create_queue_service() params = payload or {} def action() -> dict[str, Any]: require_task_retry(ctx) return queue_service.clear_terminal_jobs( ctx, statuses=params.get("statuses"), limit=int_or_default(params.get("limit"), 100), ) return handle_request(ctx, action) def _create_queue_service() -> QueueService: database = Database(load_database_settings()) return QueueService( repository=JobRepository(database), audit_service=AuditService(database), event_bus=get_default_event_bus(), ) def _create_generation_job_retry_service() -> GenerationJobRetryService: # Import lazily so route discovery does not construct provider runtimes. from backend.routes.node_routes import _create_generation_service generation_service = _create_generation_service() return GenerationJobRetryService( queue_service=generation_service.queue_service, generation_service=generation_service, )