feat(requests): let an admin reopen a rejected request (#1491)

Closes #1445, where you said you were open to it.

A rejected request was final. `update_request` won't move a terminal
status and the admin routes only fulfil or reject, so an admin who
changed their mind had to ask the user to request the book again, and
the user kept seeing the old rejected one.

`POST /api/admin/requests/<id>/reopen` moves a rejected request back to
pending and clears the review fields. What the user asked for (request
level, release, note) is kept. It refuses anything that isn't rejected,
and refuses when that user already has a pending request for the same
book.

Admins get a Reopen action on rejected cards in the activity sidebar and
in History. A rejected request has usually been cleared from the list by
the time anyone wants it back, so reopening also clears the dismissal,
the way the failed-download reopen does. Without that the pending
request stays hidden.

Tests cover the service (state change, what is kept, the refusals, a
non-string admin note) and the route, and the card model for the new
action. Ruff, tsc, oxlint, vitest and the backend suite pass. It has
been running on my instance since Oct 8.
This commit is contained in:
splitsec2 authored and GitHub committed 2026-10-20 23:20:26 -04:00
1 parent 88cc734db2
commit a1ac017487
16 files changed
+525 -3

No files matched your search

+1
View File
@@ -111,3 +111,4 @@ Admins can override the default ebook/audiobook modes and request rules for indi
4. For fulfilled requests, delivery state is tracked through the download pipeline
5. If delivery fails, an admin can reopen the request to try a different release
6. Users can cancel their own pending requests
7. An admin can **reopen** a rejected request, from the Requests tab or from History. It goes back to pending with what the user originally asked for, and shows in the activity list again even if the user had dismissed it.
+76
View File
@@ -2,6 +2,7 @@
from __future__ import annotations
import sqlite3
from typing import TYPE_CHECKING, Any
from flask import Flask, Response, jsonify, request, session
@@ -40,6 +41,7 @@ from shelfmark.core.requests_service import (
create_requests,
fulfil_request,
reject_request,
reopen_request,
)
from shelfmark.core.viewer_redaction import redact_request_row
@@ -48,6 +50,7 @@ if TYPE_CHECKING:
from flask.typing import ResponseReturnValue
from shelfmark.core.activity_view_state_service import ActivityViewStateService
from shelfmark.core.user_db import UserDB
logger = setup_logger(__name__)
@@ -562,6 +565,7 @@ def register_request_routes(
resolve_auth_mode: Callable[[], str],
queue_release: Callable[..., tuple[bool, str | None]],
ws_manager: object | None = None,
activity_view_state_service: ActivityViewStateService | None = None,
) -> None:
"""Register request policy and request lifecycle routes."""
@@ -1075,3 +1079,75 @@ def register_request_routes(
)
return jsonify(updated)
@app.route("/api/admin/requests/<int:request_id>/reopen", methods=["POST"])
def api_admin_reopen_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 = reopen_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)
# A rejected request has often been cleared from the activity list. Undo that too,
# or the reopened request stays hidden, the same as the failed-download reopen does.
if activity_view_state_service is not None:
try:
activity_view_state_service.clear_item_for_all_viewers(
item_type="request",
item_key=f"request:{updated['id']}",
)
except (OSError, ValueError, sqlite3.Error) as exc:
logger.warning(
"Could not restore reopened request #%s to the activity list: %s",
updated["id"],
exc,
)
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 reopened #%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",
)
return jsonify(updated)
+44
View File
@@ -496,6 +496,50 @@ def reject_request(
raise RequestServiceError(str(exc), status_code=409, code="stale_transition") from exc
def reopen_request(
user_db: UserDB,
*,
request_id: int,
admin_user_id: int,
admin_note: object = None,
) -> dict[str, Any]:
"""Move a rejected request back to pending as admin, so the rejection can be undone."""
request_row = ensure_request_access(
user_db,
request_id=request_id,
actor_user_id=admin_user_id,
is_admin=True,
)
if request_row["status"] != RequestStatus.REJECTED:
msg = "Only a rejected request can be reopened"
raise RequestServiceError(msg, status_code=409, code="stale_transition")
normalized_admin_note = _normalize_admin_note(admin_note)
# The user may have asked again after the rejection; two pending requests for the
# same book would both be worked.
book_data = request_row.get("book_data") or {}
if isinstance(book_data, dict):
duplicate = _find_duplicate_pending_request(
user_db,
user_id=request_row["user_id"],
title=_normalize_match_text(book_data.get("title")),
author=_normalize_match_text(book_data.get("author")),
content_type=normalize_content_type(
request_row.get("content_type") or book_data.get("content_type")
),
)
if duplicate is not None:
msg = "Duplicate pending request exists for this title/author/content_type"
raise RequestServiceError(msg, status_code=409, code="duplicate_pending_request")
reopened = user_db.reopen_rejected_request(request_id, admin_note=normalized_admin_note)
if reopened is None:
msg = "Request state changed before update"
raise RequestServiceError(msg, status_code=409, code="stale_transition")
return reopened
def fulfil_request(
user_db: UserDB,
*,
+46
View File
@@ -931,6 +931,52 @@ class UserDB:
finally:
conn.close()
def reopen_rejected_request(
self,
request_id: int,
*,
admin_note: str | None = None,
) -> dict[str, Any] | None:
"""Move a rejected request back to pending so an admin can review it again.
Terminal statuses are immutable through ``update_request``, so this is its own
narrow path, like ``reopen_failed_request``. The request keeps what the user asked
for (``request_level``, ``release_data``, ``note``); only the review is undone.
Returns None unless the request exists and is currently rejected.
"""
with self._lock:
conn = self._connect()
try:
row = conn.execute(
"SELECT status FROM download_requests WHERE id = ?",
(request_id,),
).fetchone()
if row is None or row["status"] != RequestStatus.REJECTED:
return None
conn.execute(
"""
UPDATE download_requests
SET status = 'pending',
delivery_state = 'none',
delivery_updated_at = NULL,
last_failure_reason = NULL,
admin_note = ?,
reviewed_by = NULL,
reviewed_at = NULL
WHERE id = ? AND status = 'rejected'
""",
(admin_note, request_id),
)
updated_row = conn.execute(
"SELECT * FROM download_requests WHERE id = ?",
(request_id,),
).fetchone()
conn.commit()
return self._parse_request_row(updated_row)
finally:
conn.close()
def rollback_request_fulfilment(
self,
request_id: int,
+1
View File
@@ -601,6 +601,7 @@ if user_db is not None:
resolve_auth_mode=_resolve_auth_mode_for_routes,
queue_release=_queue_release_for_routes,
ws_manager=ws_manager,
activity_view_state_service=activity_view_state_service,
)
if download_history_service is not None and activity_view_state_service is not None:
register_activity_routes(
+27
View File
@@ -356,6 +356,7 @@ function App() {
cancelRequest: cancelUserRequest,
fulfilRequest: fulfilSidebarRequest,
rejectRequest: rejectSidebarRequest,
reopenRequest: reopenSidebarRequest,
} = useRequests({
isAdmin: requestRoleIsAdmin,
});
@@ -372,6 +373,7 @@ function App() {
activityHistoryHasMore,
prefetchActivityHistory,
refreshActivitySnapshot,
refreshHistoryIfLoaded,
resetActivity,
handleActivityTabChange,
handleActivityHistoryLoadMore,
@@ -1793,6 +1795,30 @@ function App() {
[refreshActivitySnapshot, requestRoleIsAdmin, rejectSidebarRequest, showToast],
);
const handleRequestReopen = useCallback(
async (requestId: number) => {
if (!requestRoleIsAdmin) {
return;
}
try {
await reopenSidebarRequest(requestId);
await refreshActivitySnapshot();
refreshHistoryIfLoaded();
showToast('Request reopened', 'success');
} catch (error) {
showToast(getErrorMessage(error, 'Failed to reopen request'), 'error');
}
},
[
refreshActivitySnapshot,
refreshHistoryIfLoaded,
requestRoleIsAdmin,
reopenSidebarRequest,
showToast,
],
);
const handleRequestApprove = useCallback(
async (
requestId: number,
@@ -2753,6 +2779,7 @@ function App() {
onRequestCancel={showRequestsTab ? handleRequestCancel : undefined}
onRequestApprove={requestRoleIsAdmin ? handleRequestApprove : undefined}
onRequestReject={requestRoleIsAdmin ? handleRequestReject : undefined}
onRequestReopen={requestRoleIsAdmin ? handleRequestReopen : undefined}
onRequestDismiss={showRequestsTab ? handleRequestDismiss : undefined}
onPinnedOpenChange={setSidebarPinnedOpen}
pinnedTopOffset={headerHeight}
@@ -31,6 +31,7 @@ interface ActivityCardProps {
onRequestReviewApprove?: RequestApproveHandler;
onRequestReject?: (requestId: number, adminNote?: string) => Promise<void> | void;
onRequestRejectConfirm?: (requestId: number, adminNote?: string) => Promise<void> | void;
onRequestReopen?: (requestId: number) => Promise<void> | void;
onRequestDismiss?: (requestId: number) => void;
showRequestDetailsToggle?: boolean;
isRequestDetailsOpen?: boolean;
@@ -78,6 +79,7 @@ const actionKey = (action: ActivityCardAction): string => {
case 'request-approve':
return `${action.kind}-${action.requestId}-${action.record.id}`;
case 'request-reject':
case 'request-reopen':
case 'request-cancel':
case 'request-dismiss':
return `${action.kind}-${action.requestId}`;
@@ -127,6 +129,12 @@ const actionUiConfig = (
className: 'text-red-600 dark:text-red-400 hover:bg-red-100 dark:hover:bg-red-900/30',
icon: 'cross',
};
case 'request-reopen':
return {
title: 'Reopen request',
className: 'text-sky-600 dark:text-sky-400 hover:bg-sky-100 dark:hover:bg-sky-900/30',
icon: 'retry',
};
case 'request-cancel':
return {
title: 'Cancel request',
@@ -485,6 +493,7 @@ export const ActivityCard = ({
onRequestReviewApprove,
onRequestReject,
onRequestRejectConfirm,
onRequestReopen,
onRequestDismiss,
showRequestDetailsToggle = false,
isRequestDetailsOpen = false,
@@ -600,6 +609,9 @@ export const ActivityCard = ({
case 'request-reject':
void onRequestReject?.(action.requestId);
break;
case 'request-reopen':
void onRequestReopen?.(action.requestId);
break;
case 'request-cancel':
onRequestCancel?.(action.requestId);
break;
@@ -624,6 +636,8 @@ export const ActivityCard = ({
return Boolean(onRequestApprove);
case 'request-reject':
return Boolean(onRequestReject);
case 'request-reopen':
return Boolean(onRequestReopen);
case 'request-cancel':
return Boolean(onRequestCancel);
case 'request-dismiss':
@@ -42,6 +42,7 @@ interface ActivitySidebarProps {
},
) => Promise<void> | void;
onRequestReject?: (requestId: number, adminNote?: string) => Promise<void> | void;
onRequestReopen?: (requestId: number) => Promise<void> | void;
onRequestDismiss?: (requestId: number) => void;
onPinnedOpenChange?: (pinnedOpen: boolean) => void;
pinnedTopOffset?: number;
@@ -234,6 +235,7 @@ export const ActivitySidebar = ({
onRequestCancel,
onRequestApprove,
onRequestReject,
onRequestReopen,
onRequestDismiss,
onPinnedOpenChange,
pinnedTopOffset = 0,
@@ -799,7 +801,12 @@ export const ActivitySidebar = ({
return (
<div className="divide-y divide-[color-mix(in_srgb,var(--border-muted)_60%,transparent)]">
{visibleItems.map((item) => (
<ActivityCard key={item.id} item={item} isAdmin={isAdmin} />
<ActivityCard
key={item.id}
item={item}
isAdmin={isAdmin}
onRequestReopen={onRequestReopen}
/>
))}
{historyHasMore && (
<div className="pt-3 text-center">
@@ -896,6 +903,7 @@ export const ActivitySidebar = ({
}
: undefined
}
onRequestReopen={onRequestReopen}
showRequestDetailsToggle={canShowRequestReview}
isRequestDetailsOpen={shouldShowRequestReview}
isSelected={shouldShowRequestReview || shouldShowRejectDialog}
@@ -14,7 +14,7 @@ export type ActivityCardAction =
record: RequestRecord;
}
| {
kind: 'request-reject' | 'request-cancel' | 'request-dismiss';
kind: 'request-reject' | 'request-reopen' | 'request-cancel' | 'request-dismiss';
requestId: number;
};
@@ -214,6 +214,13 @@ const buildActions = (item: ActivityItem, isAdmin: boolean): ActivityCardAction[
return [{ kind: 'request-cancel', requestId: item.requestId }];
}
if (item.visualStatus === 'rejected' && isAdmin) {
return [
{ kind: 'request-reopen', requestId: item.requestId },
{ kind: 'request-dismiss', requestId: item.requestId },
];
}
if (
item.visualStatus === 'fulfilled' ||
item.visualStatus === 'rejected' ||
+2
View File
@@ -279,6 +279,7 @@ interface UseActivityResult {
activityHistoryHasMore: boolean;
prefetchActivityHistory: () => void;
refreshActivitySnapshot: () => Promise<void>;
refreshHistoryIfLoaded: () => void;
handleActivityTabChange: (tab: 'all' | 'downloads' | 'requests' | 'history') => void;
resetActivity: () => void;
handleActivityHistoryLoadMore: () => void;
@@ -570,6 +571,7 @@ export const useActivity = ({
activityHistoryHasMore,
prefetchActivityHistory,
refreshActivitySnapshot,
refreshHistoryIfLoaded,
handleActivityTabChange,
resetActivity,
handleActivityHistoryLoadMore,
+19
View File
@@ -4,6 +4,7 @@ import {
cancelRequest as cancelUserRequest,
fulfilAdminRequest,
rejectAdminRequest,
reopenAdminRequest,
} from '../services/api';
interface UseRequestsOptions {
@@ -19,6 +20,7 @@ interface UseRequestsReturn {
manualApproval?: boolean,
) => Promise<void>;
rejectRequest: (id: number, adminNote?: string) => Promise<void>;
reopenRequest: (id: number) => Promise<void>;
}
const toErrorMessage = (error: unknown, fallback: string): string => {
@@ -81,9 +83,26 @@ export const useRequests = ({ isAdmin }: UseRequestsOptions): UseRequestsReturn
[isAdmin],
);
const reopenRequest = useCallback(
async (id: number) => {
if (!isAdmin) {
throw new Error('Admin access required');
}
try {
await reopenAdminRequest(id);
} catch (err) {
const message = toErrorMessage(err, 'Failed to reopen request');
throw new Error(message, { cause: err });
}
},
[isAdmin],
);
return {
cancelRequest,
fulfilRequest,
rejectRequest,
reopenRequest,
};
};
+10
View File
@@ -709,6 +709,16 @@ export const rejectAdminRequest = async (
});
};
export const reopenAdminRequest = async (
id: number,
body: RejectAdminRequestBody = {},
): Promise<RequestRecord> => {
return fetchJSON<RequestRecord>(buildAdminRequestActionUrl(API.adminRequests, id, 'reopen'), {
method: 'POST',
body: JSON.stringify(buildRejectAdminRequestBody(body)),
});
};
// Authentication functions
export const login = async (credentials: LoginCredentials): Promise<AuthResponse> => {
return fetchJSON<AuthResponse>(API.login, {
@@ -35,7 +35,7 @@ export const buildRequestListUrl = (baseUrl: string, params: RequestListParams =
export const buildAdminRequestActionUrl = (
adminRequestsBaseUrl: string,
id: number,
action: 'fulfil' | 'reject',
action: 'fulfil' | 'reject' | 'reopen',
): string => {
return `${adminRequestsBaseUrl}/${encodeURIComponent(String(id))}/${action}`;
};
@@ -241,4 +241,36 @@ describe('activityCardModel', () => {
expect(model.actions.length).toBe(1);
expect(model.actions[0]?.kind).toBe('download-dismiss');
});
it('offers reopen on a rejected request to admins only', () => {
const rejected = makeItem({
kind: 'request',
visualStatus: 'rejected',
requestId: 43,
downloadBookId: undefined,
});
const adminModel = buildActivityCardModel(rejected, true);
expect(adminModel.actions.map((action) => action.kind)).toEqual([
'request-reopen',
'request-dismiss',
]);
const requesterModel = buildActivityCardModel(rejected, false);
expect(requesterModel.actions.map((action) => action.kind)).toEqual(['request-dismiss']);
});
it('does not offer reopen on a cancelled request', () => {
const model = buildActivityCardModel(
makeItem({
kind: 'request',
visualStatus: 'cancelled',
requestId: 44,
downloadBookId: undefined,
}),
true,
);
expect(model.actions.map((action) => action.kind)).toEqual(['request-dismiss']);
});
});
+82
View File
@@ -1308,6 +1308,88 @@ class TestRequestRoutes:
assert updated["user_id"] == user["id"]
assert updated["status"] == "rejected"
def test_admin_reopen_undoes_a_rejection(self, main_module, client):
user = _create_user(main_module, prefix="reader")
admin = _create_user(main_module, prefix="admin", role="admin")
policy = _policy(default_ebook="request_book")
_set_session(client, user_id=user["username"], db_user_id=user["id"], is_admin=False)
create_payload = {
"book_data": {
"title": "My Dog Thinks It's a Cat",
"author": "Some Author",
"content_type": "ebook",
"provider": "openlibrary",
"provider_id": "ol-reopen",
},
"context": {
"source": "direct_download",
"content_type": "ebook",
"request_level": "book",
},
}
with patch.object(main_module, "get_auth_mode", return_value="builtin"):
with patch.object(
main_module, "load_users_request_policy_settings", return_value=policy
):
with patch(
"shelfmark.core.request_routes.load_users_request_policy_settings",
return_value=policy,
):
create_resp = client.post("/api/requests", json=create_payload)
request_id = create_resp.json["id"]
reopen_as_user_resp = client.post(f"/api/admin/requests/{request_id}/reopen")
_set_session(
client, user_id=admin["username"], db_user_id=admin["id"], is_admin=True
)
reopen_pending_resp = client.post(f"/api/admin/requests/{request_id}/reopen")
client.post(
f"/api/admin/requests/{request_id}/reject",
json={"admin_note": "Sounds like a dumb book"},
)
main_module.activity_view_state_service.dismiss(
viewer_scope="admin:shared",
item_type="request",
item_key=f"request:{request_id}",
)
with patch.object(main_module.ws_manager, "is_enabled", return_value=True):
with patch.object(main_module.ws_manager.socketio, "emit") as mock_emit:
reopen_resp = client.post(
f"/api/admin/requests/{request_id}/reopen",
json={"admin_note": "Therapy book, fair enough"},
)
reopen_again_resp = client.post(f"/api/admin/requests/{request_id}/reopen")
assert create_resp.status_code == 201
assert reopen_as_user_resp.status_code == 403
assert reopen_pending_resp.status_code == 409
assert reopen_pending_resp.json["code"] == "stale_transition"
assert reopen_resp.status_code == 200
assert reopen_resp.json["status"] == "pending"
assert reopen_resp.json["admin_note"] == "Therapy book, fair enough"
assert reopen_again_resp.status_code == 409
assert mock_emit.call_count == 2
expected_payload = {
"request_id": request_id,
"status": "pending",
"title": "My Dog Thinks It's a Cat",
}
_assert_emit_call(mock_emit, 0, "request_update", expected_payload, f"user_{user['id']}")
_assert_emit_call(mock_emit, 1, "request_update", expected_payload, "admins")
updated = main_module.user_db.get_request(request_id)
assert updated["status"] == "pending"
assert updated["reviewed_by"] is None
hidden_keys = {
row["item_key"]
for row in main_module.activity_view_state_service.list_hidden(
viewer_scope="admin:shared"
)
}
assert f"request:{request_id}" not in hidden_keys
def test_admin_reject_emits_update_to_user_and_admin_rooms(self, main_module, client):
user = _create_user(main_module, prefix="reader")
admin = _create_user(main_module, prefix="admin", role="admin")
+153
View File
@@ -24,6 +24,7 @@ from shelfmark.core.requests_service import (
fulfil_request,
reject_request,
reopen_failed_request,
reopen_request,
sync_delivery_states_from_queue_status,
)
from shelfmark.core.user_db import UserDB
@@ -1642,3 +1643,155 @@ def test_create_request_normalizes_content_type_from_book_data(user_db):
)
assert created["content_type"] == "audiobook"
def _rejected_request(user_db, *, request_level="book", release_data=None, note=None):
alice = user_db.create_user(username="alice")
admin = user_db.create_user(username="admin", role="admin")
created = create_request(
user_db,
user_id=alice["id"],
source_hint="prowlarr",
content_type="ebook",
request_level=request_level,
policy_mode="request_release" if release_data else "request_book",
book_data=_book_data(),
release_data=release_data,
note=note,
)
reject_request(
user_db,
request_id=created["id"],
admin_user_id=admin["id"],
admin_note="Sounds like a dumb book",
)
return alice, admin, created
def test_reopen_request_moves_rejected_back_to_pending(user_db):
_alice, admin, created = _rejected_request(user_db)
reopened = reopen_request(user_db, request_id=created["id"], admin_user_id=admin["id"])
assert reopened["status"] == "pending"
assert reopened["reviewed_by"] is None
assert reopened["reviewed_at"] is None
assert reopened["admin_note"] is None
assert reopened["delivery_state"] == "none"
def test_reopen_request_keeps_what_the_user_asked_for(user_db):
_alice, admin, created = _rejected_request(
user_db,
request_level="release",
release_data=_release_data(),
note="It is for my dog",
)
reopened = reopen_request(
user_db,
request_id=created["id"],
admin_user_id=admin["id"],
admin_note=" Fair enough ",
)
assert reopened["request_level"] == "release"
assert reopened["release_data"] == _release_data()
assert reopened["note"] == "It is for my dog"
assert reopened["admin_note"] == "Fair enough"
@pytest.mark.parametrize("status", ["pending", "cancelled"])
def test_reopen_request_refuses_a_request_that_is_not_rejected(user_db, status):
alice = user_db.create_user(username="alice")
admin = user_db.create_user(username="admin", role="admin")
created = create_request(
user_db,
user_id=alice["id"],
source_hint="prowlarr",
content_type="ebook",
request_level="book",
policy_mode="request_book",
book_data=_book_data(),
)
if status == "cancelled":
cancel_request(user_db, request_id=created["id"], actor_user_id=alice["id"])
with pytest.raises(RequestServiceError) as exc_info:
reopen_request(user_db, request_id=created["id"], admin_user_id=admin["id"])
assert exc_info.value.status_code == 409
assert exc_info.value.code == "stale_transition"
assert user_db.get_request(created["id"])["status"] == status
def test_reopen_request_refuses_a_fulfilled_request(user_db):
alice = user_db.create_user(username="alice")
admin = user_db.create_user(username="admin", role="admin")
created = create_request(
user_db,
user_id=alice["id"],
source_hint="prowlarr",
content_type="ebook",
request_level="release",
policy_mode="request_release",
book_data=_book_data(),
release_data=_release_data(),
)
fulfil_request(
user_db,
request_id=created["id"],
admin_user_id=admin["id"],
queue_release=lambda *a, **kw: (True, None),
)
with pytest.raises(RequestServiceError) as exc_info:
reopen_request(user_db, request_id=created["id"], admin_user_id=admin["id"])
assert exc_info.value.code == "stale_transition"
assert user_db.get_request(created["id"])["status"] == "fulfilled"
def test_reopen_request_refuses_when_the_user_already_asked_again(user_db):
alice, admin, created = _rejected_request(user_db)
create_request(
user_db,
user_id=alice["id"],
source_hint="prowlarr",
content_type="ebook",
request_level="book",
policy_mode="request_book",
book_data=_book_data(),
)
with pytest.raises(RequestServiceError) as exc_info:
reopen_request(user_db, request_id=created["id"], admin_user_id=admin["id"])
assert exc_info.value.code == "duplicate_pending_request"
assert user_db.get_request(created["id"])["status"] == "rejected"
def test_reopen_request_rejects_a_non_string_admin_note(user_db):
_alice, admin, created = _rejected_request(user_db)
with pytest.raises(RequestServiceError) as exc_info:
reopen_request(user_db, request_id=created["id"], admin_user_id=admin["id"], admin_note=42)
assert exc_info.value.status_code == 400
assert user_db.get_request(created["id"])["status"] == "rejected"
def test_reopen_rejected_request_returns_none_for_unknown_or_other_states(user_db):
assert user_db.reopen_rejected_request(999_999) is None
alice = user_db.create_user(username="alice")
created = create_request(
user_db,
user_id=alice["id"],
source_hint="prowlarr",
content_type="ebook",
request_level="book",
policy_mode="request_book",
book_data=_book_data(),
)
assert user_db.reopen_rejected_request(created["id"]) is None