diff --git a/docs/users-and-requests.md b/docs/users-and-requests.md index 6411c58b..0ddb921e 100644 --- a/docs/users-and-requests.md +++ b/docs/users-and-requests.md @@ -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. diff --git a/shelfmark/core/request_routes.py b/shelfmark/core/request_routes.py index d34ec1ac..53c96c80 100644 --- a/shelfmark/core/request_routes.py +++ b/shelfmark/core/request_routes.py @@ -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//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) diff --git a/shelfmark/core/requests_service.py b/shelfmark/core/requests_service.py index 20a0596f..a1536353 100644 --- a/shelfmark/core/requests_service.py +++ b/shelfmark/core/requests_service.py @@ -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, *, diff --git a/shelfmark/core/user_db.py b/shelfmark/core/user_db.py index 42b06250..ad0734c2 100644 --- a/shelfmark/core/user_db.py +++ b/shelfmark/core/user_db.py @@ -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, diff --git a/shelfmark/main.py b/shelfmark/main.py index e48aa20a..d6c6928b 100644 --- a/shelfmark/main.py +++ b/shelfmark/main.py @@ -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( diff --git a/src/frontend/src/App.tsx b/src/frontend/src/App.tsx index 9085eb1d..687546ec 100644 --- a/src/frontend/src/App.tsx +++ b/src/frontend/src/App.tsx @@ -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} diff --git a/src/frontend/src/components/activity/ActivityCard.tsx b/src/frontend/src/components/activity/ActivityCard.tsx index 771b8312..4dacbb77 100644 --- a/src/frontend/src/components/activity/ActivityCard.tsx +++ b/src/frontend/src/components/activity/ActivityCard.tsx @@ -31,6 +31,7 @@ interface ActivityCardProps { onRequestReviewApprove?: RequestApproveHandler; onRequestReject?: (requestId: number, adminNote?: string) => Promise | void; onRequestRejectConfirm?: (requestId: number, adminNote?: string) => Promise | void; + onRequestReopen?: (requestId: number) => Promise | 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': diff --git a/src/frontend/src/components/activity/ActivitySidebar.tsx b/src/frontend/src/components/activity/ActivitySidebar.tsx index b85d6736..2c5ef884 100644 --- a/src/frontend/src/components/activity/ActivitySidebar.tsx +++ b/src/frontend/src/components/activity/ActivitySidebar.tsx @@ -42,6 +42,7 @@ interface ActivitySidebarProps { }, ) => Promise | void; onRequestReject?: (requestId: number, adminNote?: string) => Promise | void; + onRequestReopen?: (requestId: number) => Promise | 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 (
{visibleItems.map((item) => ( - + ))} {historyHasMore && (
@@ -896,6 +903,7 @@ export const ActivitySidebar = ({ } : undefined } + onRequestReopen={onRequestReopen} showRequestDetailsToggle={canShowRequestReview} isRequestDetailsOpen={shouldShowRequestReview} isSelected={shouldShowRequestReview || shouldShowRejectDialog} diff --git a/src/frontend/src/components/activity/activityCardModel.ts b/src/frontend/src/components/activity/activityCardModel.ts index 2e010838..4e7e2bd6 100644 --- a/src/frontend/src/components/activity/activityCardModel.ts +++ b/src/frontend/src/components/activity/activityCardModel.ts @@ -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' || diff --git a/src/frontend/src/hooks/useActivity.ts b/src/frontend/src/hooks/useActivity.ts index 0f10805d..4d77b080 100644 --- a/src/frontend/src/hooks/useActivity.ts +++ b/src/frontend/src/hooks/useActivity.ts @@ -279,6 +279,7 @@ interface UseActivityResult { activityHistoryHasMore: boolean; prefetchActivityHistory: () => void; refreshActivitySnapshot: () => Promise; + 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, diff --git a/src/frontend/src/hooks/useRequests.ts b/src/frontend/src/hooks/useRequests.ts index a6c461a9..df78a1d7 100644 --- a/src/frontend/src/hooks/useRequests.ts +++ b/src/frontend/src/hooks/useRequests.ts @@ -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; rejectRequest: (id: number, adminNote?: string) => Promise; + reopenRequest: (id: number) => Promise; } 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, }; }; diff --git a/src/frontend/src/services/api.ts b/src/frontend/src/services/api.ts index 77f55bec..f3f2152d 100644 --- a/src/frontend/src/services/api.ts +++ b/src/frontend/src/services/api.ts @@ -709,6 +709,16 @@ export const rejectAdminRequest = async ( }); }; +export const reopenAdminRequest = async ( + id: number, + body: RejectAdminRequestBody = {}, +): Promise => { + return fetchJSON(buildAdminRequestActionUrl(API.adminRequests, id, 'reopen'), { + method: 'POST', + body: JSON.stringify(buildRejectAdminRequestBody(body)), + }); +}; + // Authentication functions export const login = async (credentials: LoginCredentials): Promise => { return fetchJSON(API.login, { diff --git a/src/frontend/src/services/requestApiHelpers.ts b/src/frontend/src/services/requestApiHelpers.ts index 137e0d28..1bd2da42 100644 --- a/src/frontend/src/services/requestApiHelpers.ts +++ b/src/frontend/src/services/requestApiHelpers.ts @@ -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}`; }; diff --git a/src/frontend/src/tests/activityCardModel.test.ts b/src/frontend/src/tests/activityCardModel.test.ts index fd0cc53a..04899143 100644 --- a/src/frontend/src/tests/activityCardModel.test.ts +++ b/src/frontend/src/tests/activityCardModel.test.ts @@ -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']); + }); }); diff --git a/tests/core/test_request_routes_api.py b/tests/core/test_request_routes_api.py index f937e305..a6a1b498 100644 --- a/tests/core/test_request_routes_api.py +++ b/tests/core/test_request_routes_api.py @@ -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") diff --git a/tests/core/test_requests_service.py b/tests/core/test_requests_service.py index e3ed7028..f93e4f98 100644 --- a/tests/core/test_requests_service.py +++ b/tests/core/test_requests_service.py @@ -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