Files
shelfmark/shelfmark/core/request_routes.py
T
CaliBrain bac0b93566 fix: keep https:// for qBittorrent and hide release sources from non-admins (#1422)
qBittorrent over HTTPS (#1417)

qbittorrent-api ignores the scheme in `host` and probes HTTP and HTTPS
itself. When the HTTPS probe fails, for instance on a certificate
Shelfmark doesn't trust, it falls back to plain HTTP against the TLS
port, and a reverse proxy answers "400 The plain HTTP request was sent
to HTTPS port". The download client and the Test Connection button now
pass FORCE_SCHEME_FROM_HOST for https:// URLs, so the configured scheme
is used as-is and a certificate problem is reported as one. http:// and
bare host:port URLs keep the probe: normalization adds http:// to a bare
host, and the probe follows a proxy's redirect to HTTPS.

Release sources leaked to non-admins (#1418)

A download queued from an approved request carries the release an admin
picked, and the requester could read it from their own activity feed:
the request's release_data (source_id, indexer, info URL, torrent
attributes), the download's full server path, and the download id
itself, which for Prowlarr is "<indexer id>:<guid>" and for a private
tracker is a URL into it. That id keys every status payload, the
/api/localdownload query and the cover proxy URL, so hiding
release_data alone would not have closed the leak.

For non-admin viewers:
- request rows keep only the release fields the activity cards display
- download_path is reduced to the file name, which the browser download
  reveals anyway
- request-linked downloads are addressed by an opaque id (a keyed HMAC
  of the task id) in the snapshot, history, /api/status, queue order,
  active downloads, dismissed keys, cover URLs and the websocket status
  and progress events. Routes that take a download id translate it
  back, searching only the caller's own downloads.

Downloads a user queued directly keep their real id: the user picked
that release from search results that already showed it, and the
release list matches its buttons to the queue by that id. Admin views
are unchanged. The activity sidebar now links a fulfilled request to
its download by request_id instead of release_data.source_id.

Closes #1417
Closes #1418
2026-10-02 20:38:58 -04:00

1078 lines
37 KiB
Python

"""Request API routes and policy snapshot endpoint."""
from __future__ import annotations
from typing import TYPE_CHECKING, Any
from flask import Flask, Response, jsonify, request, session
from shelfmark.core.logger import setup_logger
from shelfmark.core.notifications import (
NotificationContext,
NotificationEvent,
notify_admin,
notify_user,
)
from shelfmark.core.request_helpers import (
coerce_bool,
coerce_int,
emit_ws_event,
load_users_request_policy_settings,
normalize_optional_text,
normalize_positive_int,
populate_request_usernames,
)
from shelfmark.core.request_policy import (
REQUEST_POLICY_DEFAULT_FALLBACK_MODE,
PolicyMode,
get_source_content_type_capabilities,
merge_request_policy_settings,
normalize_content_type,
normalize_source,
parse_policy_mode,
resolve_policy_mode,
)
from shelfmark.core.request_validation import RequestStatus
from shelfmark.core.requests_service import (
RequestServiceError,
cancel_request,
create_request,
create_requests,
fulfil_request,
reject_request,
)
from shelfmark.core.viewer_redaction import redact_request_row
if TYPE_CHECKING:
from collections.abc import Callable
from flask.typing import ResponseReturnValue
from shelfmark.core.user_db import UserDB
logger = setup_logger(__name__)
_NOTIFICATION_TRIGGER_ERRORS = (RuntimeError, TypeError, ValueError)
def _error_response(
message: str,
status_code: int,
*,
code: str | None = None,
required_mode: str | None = None,
) -> tuple[Response, int]:
payload: dict[str, Any] = {"error": message}
if code is not None:
payload["code"] = code
if required_mode is not None:
payload["required_mode"] = required_mode
return jsonify(payload), status_code
def _require_request_endpoints_available(
resolve_auth_mode: Callable[[], str],
) -> tuple[Response, int] | None:
auth_mode = resolve_auth_mode()
if auth_mode == "none":
return _error_response(
"Request workflow is unavailable in no-auth mode",
403,
code="requests_unavailable",
)
if "user_id" not in session:
return jsonify({"error": "Unauthorized"}), 401
return None
def _require_db_user_id() -> tuple[int | None, ResponseReturnValue | None]:
"""Return the logged-in DB user id or a ready-made error response."""
raw_user_id = session.get("db_user_id")
if raw_user_id is None:
return None, _error_response(
"User identity is unavailable for request workflow",
403,
code="user_identity_unavailable",
)
normalized_user_id = normalize_positive_int(raw_user_id)
if normalized_user_id is None:
return None, _error_response(
"User identity is unavailable for request workflow",
403,
code="user_identity_unavailable",
)
return normalized_user_id, None
def _require_admin_user_id() -> tuple[int | None, ResponseReturnValue | None]:
if not session.get("is_admin", False):
return None, (jsonify({"error": "Admin access required"}), 403)
raw_admin_id = session.get("db_user_id")
if raw_admin_id is None:
return None, (jsonify({"error": "Admin user identity unavailable"}), 403)
normalized_admin_user_id = normalize_positive_int(raw_admin_id)
if normalized_admin_user_id is None:
return None, (jsonify({"error": "Admin user identity unavailable"}), 403)
return normalized_admin_user_id, None
def _resolve_effective_policy(
user_db: UserDB,
*,
db_user_id: int | None,
) -> tuple[dict[str, Any], dict[str, Any], dict[str, Any], bool]:
global_settings = load_users_request_policy_settings()
user_settings = user_db.get_user_settings(db_user_id) if db_user_id is not None else {}
effective = merge_request_policy_settings(global_settings, user_settings)
requests_enabled = coerce_bool(effective.get("REQUESTS_ENABLED"), default=False)
return global_settings, user_settings, effective, requests_enabled
def _resolve_title_from_book_data(book_data: object) -> str:
if isinstance(book_data, dict):
title = normalize_optional_text(book_data.get("title"))
if title is not None:
return title
return "Unknown title"
def _normalize_optional_source_id(value: object) -> str | None:
"""Normalize source identifiers while allowing integer provider ids."""
if isinstance(value, bool) or value is None:
return None
if isinstance(value, int):
value = str(value)
return normalize_optional_text(value)
def _build_release_result_data_from_book_data(
*,
source: str,
book_data: dict[str, Any],
content_type: str,
) -> dict[str, Any]:
"""Build release-level payload fields for sources whose browse results are releases."""
source_id = _normalize_optional_source_id(
book_data.get("provider_id")
) or _normalize_optional_source_id(book_data.get("id"))
payload: dict[str, Any] = {
"source": source,
"source_id": source_id,
"title": book_data.get("title"),
"author": book_data.get("author"),
"year": book_data.get("year"),
"format": book_data.get("format"),
"size": book_data.get("size"),
"preview": book_data.get("preview"),
"content_type": content_type,
"source_url": book_data.get("source_url"),
"search_mode": "direct",
}
return {key: value for key, value in payload.items() if value is not None}
def _source_results_are_releases(source: str) -> bool:
normalized_source = normalize_source(source)
if normalized_source in {"", "*"}:
return False
from shelfmark.release_sources import source_results_are_releases
return source_results_are_releases(normalized_source)
def _normalize_release_result_request_payload(
*,
source: str,
request_level: object,
book_data: object,
release_data: object,
content_type: str,
) -> tuple[Any, Any]:
"""Concrete-release browse results are always handled as release-level requests."""
if not _source_results_are_releases(source):
return request_level, release_data
normalized_release_data = release_data
if normalized_release_data is None and isinstance(book_data, dict):
normalized_release_data = _build_release_result_data_from_book_data(
source=source,
book_data=book_data,
content_type=content_type,
)
elif isinstance(normalized_release_data, dict):
normalized_release_data = dict(normalized_release_data)
if isinstance(normalized_release_data, dict):
normalized_release_data["source"] = source
if normalized_release_data.get("content_type") is None:
normalized_release_data["content_type"] = content_type
normalized_source_id = _normalize_optional_source_id(
normalized_release_data.get("source_id")
)
if normalized_source_id is not None:
normalized_release_data["source_id"] = normalized_source_id
elif isinstance(book_data, dict):
fallback_source_id = _normalize_optional_source_id(
book_data.get("provider_id")
) or _normalize_optional_source_id(book_data.get("id"))
if fallback_source_id is not None:
normalized_release_data["source_id"] = fallback_source_id
return "release", normalized_release_data
def _validate_release_source_matches_policy_context(
*,
source: str,
release_data: object,
) -> None:
if not isinstance(release_data, dict):
return
release_source = normalize_source(release_data.get("source"))
if release_source in {"", "*"} or release_source == source:
return
msg = "Policy context source must match release_data.source"
raise RequestServiceError(
msg,
status_code=400,
code="policy_source_mismatch",
)
def _resolve_request_title(request_row: dict[str, Any]) -> str:
return _resolve_title_from_book_data(request_row.get("book_data"))
def _format_user_label(username: str | None, user_id: int | None = None) -> str:
normalized_username = normalize_optional_text(username)
if normalized_username is not None:
return normalized_username
if user_id is not None and user_id > 0:
return f"user#{user_id}"
return "unknown user"
def _format_requester_label(user_db: UserDB, request_row: dict[str, Any]) -> str:
"""Resolve a display label for the user who created a request."""
user_id = normalize_positive_int(request_row.get("user_id"))
if user_id is not None:
requester = user_db.get_user(user_id=user_id)
if isinstance(requester, dict):
username = normalize_optional_text(requester.get("username"))
if username is not None:
return username
return _format_user_label(None, user_id)
def _resolve_request_user_context(
user_db: UserDB,
*,
actor_user_id: int,
actor_username: str | None,
on_behalf_of_user_id: object,
) -> tuple[int, str | None, str]:
if on_behalf_of_user_id in (None, ""):
actor_label = _format_user_label(actor_username, actor_user_id)
return actor_user_id, actor_username, actor_label
if not session.get("is_admin", False):
msg = "Admin required"
raise RequestServiceError(msg, status_code=403)
target_user_id = normalize_positive_int(on_behalf_of_user_id)
if target_user_id is None:
msg = "Invalid on_behalf_of_user_id"
raise RequestServiceError(msg, status_code=400)
target_user = user_db.get_user(user_id=target_user_id)
if not target_user:
msg = "User not found"
raise RequestServiceError(msg, status_code=404)
target_username = normalize_optional_text(target_user.get("username"))
actor_label = _format_user_label(actor_username, actor_user_id)
target_label = _format_user_label(target_username, target_user_id)
return target_user_id, target_username, f"{actor_label} on behalf of {target_label}"
def _prepare_request_create_arguments(
user_db: UserDB,
data: dict[str, Any],
) -> dict[str, Any]:
db_user_id, db_gate = _require_db_user_id()
if db_gate is not None or db_user_id is None:
msg = "User identity is unavailable for request workflow"
raise RequestServiceError(
msg,
status_code=403,
code="user_identity_unavailable",
)
actor_username = normalize_optional_text(session.get("user_id"))
target_user_id, _, actor_label = _resolve_request_user_context(
user_db,
actor_user_id=db_user_id,
actor_username=actor_username,
on_behalf_of_user_id=data.get("on_behalf_of_user_id"),
)
context = data.get("context") or {}
if not isinstance(context, dict):
msg = "context must be an object"
raise RequestServiceError(msg, status_code=400)
source = normalize_source(context.get("source"))
release_data = data.get("release_data")
request_level = context.get("request_level")
if request_level is None:
request_level = "book" if release_data is None else "release"
book_data = data.get("book_data")
if not isinstance(book_data, dict):
msg = "book_data must be an object"
raise RequestServiceError(msg, status_code=400)
request_title = _resolve_title_from_book_data(book_data)
content_type = normalize_content_type(
context.get("content_type") or data.get("content_type") or book_data.get("content_type")
)
_validate_release_source_matches_policy_context(
source=source,
release_data=release_data,
)
request_level, release_data = _normalize_release_result_request_payload(
source=source,
request_level=request_level,
book_data=book_data,
release_data=release_data,
content_type=content_type,
)
_validate_release_source_matches_policy_context(
source=source,
release_data=release_data,
)
global_settings, user_settings, effective, requests_enabled = _resolve_effective_policy(
user_db,
db_user_id=target_user_id,
)
if not requests_enabled:
msg = "Request workflow is disabled by policy"
raise RequestServiceError(
msg,
status_code=403,
code="requests_unavailable",
)
max_pending = coerce_int(
effective.get("MAX_PENDING_REQUESTS_PER_USER"),
default=20,
)
max_pending = max(max_pending, 1)
max_pending = min(max_pending, 1000)
allow_notes = coerce_bool(effective.get("REQUESTS_ALLOW_NOTES"), default=True)
note_value = data.get("note") if allow_notes else None
resolved_mode = resolve_policy_mode(
source=source,
content_type=content_type,
global_settings=global_settings,
user_settings=user_settings,
)
logger.debug(
"request create policy actor=%s target_user_id=%s source=%s content_type=%s request_level=%s resolved_mode=%s",
actor_label,
target_user_id,
source,
content_type,
request_level,
resolved_mode.value,
)
if resolved_mode == PolicyMode.BLOCKED:
msg = "Requesting is blocked by policy"
raise RequestServiceError(
msg,
status_code=403,
code="policy_blocked",
required_mode=PolicyMode.BLOCKED.value,
)
requested_level = str(request_level).strip().lower() if isinstance(request_level, str) else ""
if resolved_mode == PolicyMode.REQUEST_BOOK and requested_level != "book":
msg = "Policy requires book-level requests"
raise RequestServiceError(
msg,
status_code=403,
code="policy_requires_request",
required_mode=PolicyMode.REQUEST_BOOK.value,
)
return {
"create_args": {
"user_id": target_user_id,
"source_hint": source,
"content_type": content_type,
"request_level": request_level,
"policy_mode": resolved_mode.value,
"book_data": book_data,
"release_data": release_data,
"note": note_value,
"max_pending_per_user": max_pending,
},
"actor_label": actor_label,
"request_title": request_title,
"resolved_mode": resolved_mode,
}
def _resolve_request_source_and_format(
request_row: dict[str, Any],
) -> tuple[str, str | None]:
release_data = request_row.get("release_data")
if isinstance(release_data, dict):
source = normalize_source(release_data.get("source") or request_row.get("source_hint"))
release_format = normalize_optional_text(
release_data.get("format")
or release_data.get("filetype")
or release_data.get("extension")
)
return source, release_format
return normalize_source(request_row.get("source_hint")), None
def _build_queued_download_result(
*,
create_args: dict[str, Any],
request_title: str,
) -> dict[str, Any]:
release_data = create_args.get("release_data")
source = create_args.get("source_hint")
source_id: str | None = None
if isinstance(release_data, dict):
source = release_data.get("source") or source
source_id = _normalize_optional_source_id(release_data.get("source_id"))
return {
"kind": "download",
"status": "queued",
"priority": 0,
"title": request_title,
"source": normalize_source(source),
"source_id": source_id,
"content_type": create_args.get("content_type"),
}
def _queue_prepared_download_submission(
user_db: UserDB,
*,
queue_release: Callable[..., tuple[bool, str | None]],
create_args: dict[str, Any],
request_title: str,
) -> dict[str, Any]:
release_data = create_args.get("release_data")
if not isinstance(release_data, dict):
msg = "Download policy requires a concrete release"
raise RequestServiceError(
msg,
status_code=400,
code="policy_requires_download",
required_mode=PolicyMode.DOWNLOAD.value,
)
requester = user_db.get_user(user_id=create_args["user_id"])
if requester is None:
msg = "Requesting user not found"
raise RequestServiceError(msg, status_code=404)
success, error = queue_release(
dict(release_data),
0,
user_id=create_args["user_id"],
username=requester.get("username"),
)
if not success:
raise RequestServiceError(
error or "Failed to queue release",
status_code=409,
code="queue_failed",
)
return _build_queued_download_result(
create_args=create_args,
request_title=request_title,
)
def _notify_admin_for_request_event(
user_db: UserDB,
*,
event: NotificationEvent,
request_row: dict[str, Any],
) -> None:
book_data = request_row.get("book_data")
if not isinstance(book_data, dict):
book_data = {}
source, release_format = _resolve_request_source_and_format(request_row)
context = NotificationContext(
event=event,
title=str(book_data.get("title") or "Unknown title"),
author=str(book_data.get("author") or "Unknown author"),
username=_format_requester_label(user_db, request_row),
content_type=normalize_content_type(
request_row.get("content_type") or book_data.get("content_type")
),
format=release_format,
source=source,
admin_note=normalize_optional_text(request_row.get("admin_note")),
error_message=None,
)
owner_user_id = normalize_positive_int(request_row.get("user_id"))
try:
notify_admin(event, context)
except _NOTIFICATION_TRIGGER_ERRORS as exc:
logger.warning(
"Failed to trigger admin notification for request event '%s': %s",
event.value,
exc,
)
if owner_user_id is None:
return
try:
notify_user(owner_user_id, event, context)
except _NOTIFICATION_TRIGGER_ERRORS as exc:
logger.warning(
"Failed to trigger user notification for request event '%s' (user_id=%s): %s",
event.value,
owner_user_id,
exc,
)
def register_request_routes(
app: Flask,
user_db: UserDB,
*,
resolve_auth_mode: Callable[[], str],
queue_release: Callable[..., tuple[bool, str | None]],
ws_manager: object | None = None,
) -> None:
"""Register request policy and request lifecycle routes."""
@app.route("/api/request-policy", methods=["GET"])
def api_request_policy() -> ResponseReturnValue:
auth_gate = _require_request_endpoints_available(resolve_auth_mode)
if auth_gate is not None:
return auth_gate
is_admin = bool(session.get("is_admin", False))
db_user_id: int | None = None
if not is_admin:
db_user_id, db_gate = _require_db_user_id()
if db_gate is not None:
return db_gate
else:
db_user_id = normalize_positive_int(session.get("db_user_id"))
global_settings, user_settings, effective, requests_enabled = _resolve_effective_policy(
user_db,
db_user_id=db_user_id,
)
default_ebook_mode = parse_policy_mode(effective.get("REQUEST_POLICY_DEFAULT_EBOOK"))
default_audio_mode = parse_policy_mode(effective.get("REQUEST_POLICY_DEFAULT_AUDIOBOOK"))
source_capabilities = get_source_content_type_capabilities()
from shelfmark.release_sources import source_results_are_releases
source_modes = []
for source_name in sorted(source_capabilities):
supported_types = sorted(
source_capabilities[source_name],
key=lambda ct: (ct != "ebook", ct),
)
modes = {
content_type: resolve_policy_mode(
source=source_name,
content_type=content_type,
global_settings=global_settings,
user_settings=user_settings,
).value
for content_type in supported_types
}
source_modes.append(
{
"source": source_name,
"supported_content_types": supported_types,
"browse_results_are_releases": source_results_are_releases(source_name),
"modes": modes,
}
)
return jsonify(
{
"requests_enabled": requests_enabled,
"is_admin": is_admin,
"allow_notes": coerce_bool(effective.get("REQUESTS_ALLOW_NOTES"), default=True),
"defaults": {
"ebook": (
default_ebook_mode.value
if default_ebook_mode is not None
else REQUEST_POLICY_DEFAULT_FALLBACK_MODE.value
),
"audiobook": (
default_audio_mode.value
if default_audio_mode is not None
else REQUEST_POLICY_DEFAULT_FALLBACK_MODE.value
),
},
"rules": effective.get("REQUEST_POLICY_RULES", []),
"source_modes": source_modes,
}
)
@app.route("/api/requests", methods=["POST"])
def api_create_request() -> ResponseReturnValue:
auth_gate = _require_request_endpoints_available(resolve_auth_mode)
if auth_gate is not None:
return auth_gate
data = request.get_json(silent=True)
if not isinstance(data, dict):
return jsonify({"error": "No data provided"}), 400
try:
prepared = _prepare_request_create_arguments(user_db, data)
if prepared["resolved_mode"] == PolicyMode.DOWNLOAD:
queued = _queue_prepared_download_submission(
user_db,
queue_release=queue_release,
create_args=prepared["create_args"],
request_title=prepared["request_title"],
)
logger.info(
"Policy download queued for '%s' by %s",
prepared["request_title"],
prepared["actor_label"],
)
return jsonify(queued), 200
created = create_request(user_db, **prepared["create_args"])
except RequestServiceError as exc:
return _error_response(
str(exc),
exc.status_code,
code=exc.code,
required_mode=exc.required_mode,
)
event_payload = {
"request_id": created["id"],
"status": created["status"],
"title": _resolve_request_title(created),
}
logger.info(
"Request created #%s for '%s' by %s",
created["id"],
event_payload["title"],
prepared["actor_label"],
)
emit_ws_event(
ws_manager,
event_name="new_request",
payload=event_payload,
room="admins",
)
emit_ws_event(
ws_manager,
event_name="request_update",
payload=event_payload,
room=f"user_{created['user_id']}",
)
_notify_admin_for_request_event(
user_db,
event=NotificationEvent.REQUEST_CREATED,
request_row=created,
)
return jsonify(created), 201
@app.route("/api/requests/batch", methods=["POST"])
def api_create_requests_batch() -> ResponseReturnValue:
auth_gate = _require_request_endpoints_available(resolve_auth_mode)
if auth_gate is not None:
return auth_gate
data = request.get_json(silent=True)
if not isinstance(data, dict):
return jsonify({"error": "No data provided"}), 400
raw_requests = data.get("requests")
if not isinstance(raw_requests, list) or len(raw_requests) == 0:
return jsonify({"error": "requests must contain at least one request"}), 400
if not all(isinstance(raw_request, dict) for raw_request in raw_requests):
return jsonify({"error": "requests must contain objects"}), 400
try:
prepared_requests = [
_prepare_request_create_arguments(user_db, raw_request)
for raw_request in raw_requests
]
except RequestServiceError as exc:
return _error_response(
str(exc),
exc.status_code,
code=exc.code,
required_mode=exc.required_mode,
)
request_prepared_items: list[tuple[int, dict[str, Any]]] = []
download_prepared_items: list[tuple[int, dict[str, Any]]] = []
for index, prepared in enumerate(prepared_requests):
if prepared["resolved_mode"] == PolicyMode.DOWNLOAD:
download_prepared_items.append((index, prepared))
continue
request_prepared_items.append((index, prepared))
created_rows: list[dict[str, Any]] = []
if request_prepared_items:
try:
created_rows = create_requests(
user_db,
requests=[prepared["create_args"] for _, prepared in request_prepared_items],
)
except RequestServiceError as exc:
return _error_response(
str(exc),
exc.status_code,
code=exc.code,
required_mode=exc.required_mode,
)
results_by_index: dict[int, dict[str, Any]] = {}
for (index, prepared), created in zip(
request_prepared_items,
created_rows,
strict=True,
):
event_payload = {
"request_id": created["id"],
"status": created["status"],
"title": _resolve_request_title(created),
}
logger.info(
"Request created #%s for '%s' by %s",
created["id"],
event_payload["title"],
prepared["actor_label"],
)
emit_ws_event(
ws_manager,
event_name="new_request",
payload=event_payload,
room="admins",
)
emit_ws_event(
ws_manager,
event_name="request_update",
payload=event_payload,
room=f"user_{created['user_id']}",
)
_notify_admin_for_request_event(
user_db,
event=NotificationEvent.REQUEST_CREATED,
request_row=created,
)
results_by_index[index] = created
for index, prepared in download_prepared_items:
try:
results_by_index[index] = _queue_prepared_download_submission(
user_db,
queue_release=queue_release,
create_args=prepared["create_args"],
request_title=prepared["request_title"],
)
except RequestServiceError as exc:
return _error_response(
str(exc),
exc.status_code,
code=exc.code,
required_mode=exc.required_mode,
)
logger.info(
"Policy download queued for '%s' by %s",
prepared["request_title"],
prepared["actor_label"],
)
ordered_results = [results_by_index[index] for index in range(len(prepared_requests))]
status_code = 201 if request_prepared_items else 200
return jsonify(ordered_results), status_code
@app.route("/api/requests", methods=["GET"])
def api_list_requests() -> ResponseReturnValue:
auth_gate = _require_request_endpoints_available(resolve_auth_mode)
if auth_gate is not None:
return auth_gate
db_user_id, db_gate = _require_db_user_id()
if db_gate is not None:
return db_gate
if db_user_id is None:
return _error_response(
"User identity is unavailable for request workflow",
403,
code="user_identity_unavailable",
)
status = request.args.get("status")
limit = request.args.get("limit", type=int)
offset = request.args.get("offset", type=int, default=0) or 0
try:
rows = user_db.list_requests(
user_id=db_user_id,
status=status,
limit=limit,
offset=offset,
)
except ValueError as exc:
return jsonify({"error": str(exc)}), 400
if not session.get("is_admin", False):
# A fulfilled request carries the release an admin picked (#1418).
rows = [redact_request_row(row) for row in rows]
return jsonify(rows)
@app.route("/api/requests/<int:request_id>", methods=["DELETE"])
def api_cancel_request(request_id: int) -> ResponseReturnValue:
auth_gate = _require_request_endpoints_available(resolve_auth_mode)
if auth_gate is not None:
return auth_gate
db_user_id, db_gate = _require_db_user_id()
if db_gate is not None:
return db_gate
if db_user_id is None:
return _error_response(
"User identity is unavailable for request workflow",
403,
code="user_identity_unavailable",
)
try:
updated = cancel_request(
user_db,
request_id=request_id,
actor_user_id=db_user_id,
)
except RequestServiceError as exc:
return _error_response(str(exc), exc.status_code, code=exc.code)
event_payload = {
"request_id": updated["id"],
"status": updated["status"],
"title": _resolve_request_title(updated),
}
actor_label = _format_user_label(
normalize_optional_text(session.get("user_id")), db_user_id
)
logger.info(
"Request cancelled #%s for '%s' by %s",
updated["id"],
event_payload["title"],
actor_label,
)
emit_ws_event(
ws_manager,
event_name="request_update",
payload=event_payload,
room=f"user_{db_user_id}",
)
emit_ws_event(
ws_manager,
event_name="request_update",
payload=event_payload,
room="admins",
)
if not session.get("is_admin", False):
updated = redact_request_row(updated)
return jsonify(updated)
@app.route("/api/admin/requests", methods=["GET"])
def api_admin_list_requests() -> ResponseReturnValue:
auth_gate = _require_request_endpoints_available(resolve_auth_mode)
if auth_gate is not None:
return auth_gate
if not session.get("is_admin", False):
return jsonify({"error": "Admin access required"}), 403
status = request.args.get("status")
limit = request.args.get("limit", type=int)
offset = request.args.get("offset", type=int, default=0) or 0
try:
rows = user_db.list_requests(status=status, limit=limit, offset=offset)
except ValueError as exc:
return jsonify({"error": str(exc)}), 400
populate_request_usernames(rows, user_db)
return jsonify(rows)
@app.route("/api/admin/requests/count", methods=["GET"])
def api_admin_request_counts() -> ResponseReturnValue:
auth_gate = _require_request_endpoints_available(resolve_auth_mode)
if auth_gate is not None:
return auth_gate
if not session.get("is_admin", False):
return jsonify({"error": "Admin access required"}), 403
by_status = {status: len(user_db.list_requests(status=status)) for status in RequestStatus}
return jsonify(
{
"pending": by_status[RequestStatus.PENDING],
"total": sum(by_status.values()),
"by_status": by_status,
}
)
@app.route("/api/admin/requests/<int:request_id>/fulfil", methods=["POST"])
def api_admin_fulfil_request(request_id: int) -> ResponseReturnValue:
auth_gate = _require_request_endpoints_available(resolve_auth_mode)
if auth_gate is not None:
return auth_gate
admin_user_id, admin_gate = _require_admin_user_id()
if admin_gate is not None:
return admin_gate
if admin_user_id is None:
return jsonify({"error": "Admin user identity unavailable"}), 403
data = request.get_json(silent=True) or {}
if not isinstance(data, dict):
return jsonify({"error": "Invalid payload"}), 400
try:
updated = fulfil_request(
user_db,
request_id=request_id,
admin_user_id=admin_user_id,
queue_release=queue_release,
release_data=data.get("release_data"),
admin_note=data.get("admin_note"),
manual_approval=data.get("manual_approval", False),
)
except RequestServiceError as exc:
return _error_response(str(exc), exc.status_code, code=exc.code)
event_payload = {
"request_id": updated["id"],
"status": updated["status"],
"title": _resolve_request_title(updated),
}
admin_label = _format_user_label(
normalize_optional_text(session.get("user_id")), admin_user_id
)
requester_label = _format_requester_label(user_db, updated)
logger.info(
"Request fulfilled #%s for '%s' by %s (requested by %s)",
updated["id"],
event_payload["title"],
admin_label,
requester_label,
)
emit_ws_event(
ws_manager,
event_name="request_update",
payload=event_payload,
room=f"user_{updated['user_id']}",
)
emit_ws_event(
ws_manager,
event_name="request_update",
payload=event_payload,
room="admins",
)
_notify_admin_for_request_event(
user_db,
event=NotificationEvent.REQUEST_FULFILLED,
request_row=updated,
)
return jsonify(updated)
@app.route("/api/admin/requests/<int:request_id>/reject", methods=["POST"])
def api_admin_reject_request(request_id: int) -> ResponseReturnValue:
auth_gate = _require_request_endpoints_available(resolve_auth_mode)
if auth_gate is not None:
return auth_gate
admin_user_id, admin_gate = _require_admin_user_id()
if admin_gate is not None:
return admin_gate
if admin_user_id is None:
return jsonify({"error": "Admin user identity unavailable"}), 403
data = request.get_json(silent=True) or {}
if not isinstance(data, dict):
return jsonify({"error": "Invalid payload"}), 400
try:
updated = reject_request(
user_db,
request_id=request_id,
admin_user_id=admin_user_id,
admin_note=data.get("admin_note"),
)
except RequestServiceError as exc:
return _error_response(str(exc), exc.status_code, code=exc.code)
event_payload = {
"request_id": updated["id"],
"status": updated["status"],
"title": _resolve_request_title(updated),
}
admin_label = _format_user_label(
normalize_optional_text(session.get("user_id")), admin_user_id
)
requester_label = _format_requester_label(user_db, updated)
logger.info(
"Request rejected #%s for '%s' by %s (requested by %s)",
updated["id"],
event_payload["title"],
admin_label,
requester_label,
)
emit_ws_event(
ws_manager,
event_name="request_update",
payload=event_payload,
room=f"user_{updated['user_id']}",
)
emit_ws_event(
ws_manager,
event_name="request_update",
payload=event_payload,
room="admins",
)
_notify_admin_for_request_event(
user_db,
event=NotificationEvent.REQUEST_REJECTED,
request_row=updated,
)
return jsonify(updated)