release: 2901262036

backend/app/routers/admin.py

@@ -1,4 +1,4 @@
-from typing import Any, Dict, List
+from typing import Any, Dict, List, Optional
 import os
 
 from fastapi import APIRouter, HTTPException, Depends, UploadFile, File
@@ -12,7 +12,11 @@ from ..db import (
     get_request_cache_missing_titles,
     get_request_cache_stats,
     get_settings_overrides,
+    get_user_by_id,
     get_user_by_username,
+    get_user_request_stats,
+    create_user_if_missing,
+    set_user_jellyseerr_id,
     set_setting,
     set_user_blocked,
     set_user_password,
@@ -24,6 +28,7 @@ from ..db import (
     cleanup_history,
     update_request_cache_title,
     repair_request_cache_titles,
+    delete_non_admin_users,
 )
 from ..runtime import get_runtime_settings
 from ..clients.sonarr import SonarrClient
@@ -87,6 +92,12 @@ SETTING_KEYS: List[str] = [
     "site_changelog",
 ]
 
+def _normalize_username(value: str) -> str:
+    normalized = value.strip().lower()
+    if "@" in normalized:
+        normalized = normalized.split("@", 1)[0]
+    return normalized
+
 def _normalize_root_folders(folders: Any) -> List[Dict[str, Any]]:
     if not isinstance(folders, list):
         return []
@@ -250,6 +261,127 @@ async def jellyfin_users_sync() -> Dict[str, Any]:
     imported = await sync_jellyfin_users()
     return {"status": "ok", "imported": imported}
 
+def _normalized_handles(value: Any) -> List[str]:
+    if not isinstance(value, str):
+        return []
+    normalized = value.strip().lower()
+    if not normalized:
+        return []
+    handles = [normalized]
+    if "@" in normalized:
+        handles.append(normalized.split("@", 1)[0])
+    return handles
+
+def _extract_user_candidates(user: Dict[str, Any]) -> List[str]:
+    candidates: List[str] = []
+    for key in ("username", "email", "displayName", "name"):
+        candidates.extend(_normalized_handles(user.get(key)))
+    return list(dict.fromkeys(candidates))
+
+async def _fetch_all_jellyseerr_users(client: JellyseerrClient) -> List[Dict[str, Any]]:
+    users: List[Dict[str, Any]] = []
+    take = 100
+    skip = 0
+    while True:
+        payload = await client.get_users(take=take, skip=skip)
+        if not payload:
+            break
+        if isinstance(payload, list):
+            batch = payload
+        elif isinstance(payload, dict):
+            batch = payload.get("results") or payload.get("users") or payload.get("data") or payload.get("items")
+        else:
+            batch = None
+        if not isinstance(batch, list) or not batch:
+            break
+        users.extend([user for user in batch if isinstance(user, dict)])
+        if len(batch) < take:
+            break
+        skip += take
+    return users
+
+@router.post("/jellyseerr/users/sync")
+async def jellyseerr_users_sync() -> Dict[str, Any]:
+    runtime = get_runtime_settings()
+    client = JellyseerrClient(runtime.jellyseerr_base_url, runtime.jellyseerr_api_key)
+    if not client.configured():
+        raise HTTPException(status_code=400, detail="Jellyseerr not configured")
+    jellyseerr_users = await _fetch_all_jellyseerr_users(client)
+    if not jellyseerr_users:
+        return {"status": "ok", "matched": 0, "skipped": 0, "total": 0}
+
+    candidate_to_id: Dict[str, int] = {}
+    for user in jellyseerr_users:
+        user_id = user.get("id") or user.get("userId") or user.get("Id")
+        try:
+            user_id = int(user_id)
+        except (TypeError, ValueError):
+            continue
+        for candidate in _extract_user_candidates(user):
+            candidate_to_id.setdefault(candidate, user_id)
+
+    updated = 0
+    skipped = 0
+    users = get_all_users()
+    for user in users:
+        if user.get("jellyseerr_user_id") is not None:
+            skipped += 1
+            continue
+        username = user.get("username") or ""
+        matched_id = None
+        for handle in _normalized_handles(username):
+            matched_id = candidate_to_id.get(handle)
+            if matched_id is not None:
+                break
+        if matched_id is not None:
+            set_user_jellyseerr_id(username, matched_id)
+            updated += 1
+        else:
+            skipped += 1
+
+    return {"status": "ok", "matched": updated, "skipped": skipped, "total": len(users)}
+
+def _pick_jellyseerr_username(user: Dict[str, Any]) -> Optional[str]:
+    for key in ("email", "username", "displayName", "name"):
+        value = user.get(key)
+        if isinstance(value, str) and value.strip():
+            return value.strip()
+    return None
+
+
+@router.post("/jellyseerr/users/resync")
+async def jellyseerr_users_resync() -> Dict[str, Any]:
+    runtime = get_runtime_settings()
+    client = JellyseerrClient(runtime.jellyseerr_base_url, runtime.jellyseerr_api_key)
+    if not client.configured():
+        raise HTTPException(status_code=400, detail="Jellyseerr not configured")
+    jellyseerr_users = await _fetch_all_jellyseerr_users(client)
+    if not jellyseerr_users:
+        return {"status": "ok", "imported": 0, "cleared": 0}
+
+    cleared = delete_non_admin_users()
+    imported = 0
+    for user in jellyseerr_users:
+        user_id = user.get("id") or user.get("userId") or user.get("Id")
+        try:
+            user_id = int(user_id)
+        except (TypeError, ValueError):
+            continue
+        username = _pick_jellyseerr_username(user)
+        if not username:
+            continue
+        created = create_user_if_missing(
+            username,
+            "jellyseerr-user",
+            role="user",
+            auth_provider="jellyseerr",
+            jellyseerr_user_id=user_id,
+        )
+        if created:
+            imported += 1
+        else:
+            set_user_jellyseerr_id(username, user_id)
+    return {"status": "ok", "imported": imported, "cleared": cleared}
 
 @router.post("/requests/sync")
 async def requests_sync() -> Dict[str, Any]:
@@ -397,9 +529,39 @@ async def clear_logs() -> Dict[str, Any]:
 
 @router.get("/users")
 async def list_users() -> Dict[str, Any]:
-    users = get_all_users()
+    users = [user for user in get_all_users() if user.get("role") == "admin" or user.get("auth_provider") == "jellyseerr"]
     return {"users": users}
 
+@router.get("/users/summary")
+async def list_users_summary() -> Dict[str, Any]:
+    users = [user for user in get_all_users() if user.get("role") == "admin" or user.get("auth_provider") == "jellyseerr"]
+    results: list[Dict[str, Any]] = []
+    for user in users:
+        username = user.get("username") or ""
+        username_norm = _normalize_username(username) if username else ""
+        stats = get_user_request_stats(username_norm, user.get("jellyseerr_user_id"))
+        results.append({**user, "stats": stats})
+    return {"users": results}
+
+@router.get("/users/{username}")
+async def get_user_summary(username: str) -> Dict[str, Any]:
+    user = get_user_by_username(username)
+    if not user:
+        raise HTTPException(status_code=404, detail="User not found")
+    username_norm = _normalize_username(user.get("username") or "")
+    stats = get_user_request_stats(username_norm, user.get("jellyseerr_user_id"))
+    return {"user": user, "stats": stats}
+
+
+@router.get("/users/id/{user_id}")
+async def get_user_summary_by_id(user_id: int) -> Dict[str, Any]:
+    user = get_user_by_id(user_id)
+    if not user:
+        raise HTTPException(status_code=404, detail="User not found")
+    username_norm = _normalize_username(user.get("username") or "")
+    stats = get_user_request_stats(username_norm, user.get("jellyseerr_user_id"))
+    return {"user": user, "stats": stats}
+
 
 @router.post("/users/{username}/block")
 async def block_user(username: str) -> Dict[str, Any]:

backend/app/routers/auth.py

@@ -10,6 +10,7 @@ from ..db import (
     get_user_by_username,
     set_user_password,
     set_jellyfin_auth_cache,
+    set_user_jellyseerr_id,
     get_user_activity,
     get_user_activity_summary,
     get_user_request_stats,
@@ -26,7 +27,10 @@ router = APIRouter(prefix="/auth", tags=["auth"])
 
 
 def _normalize_username(value: str) -> str:
-    return value.strip().lower()
+    normalized = value.strip().lower()
+    if "@" in normalized:
+        normalized = normalized.split("@", 1)[0]
+    return normalized
 
 
 def _is_recent_jellyfin_auth(last_auth_at: str) -> bool:
@@ -53,6 +57,22 @@ def _has_valid_jellyfin_cache(user: dict, password: str) -> bool:
         return False
     return _is_recent_jellyfin_auth(last_auth_at)
 
+def _extract_jellyseerr_user_id(response: dict) -> int | None:
+    if not isinstance(response, dict):
+        return None
+    candidate = response
+    if isinstance(response.get("user"), dict):
+        candidate = response.get("user")
+    for key in ("id", "userId", "Id"):
+        value = candidate.get(key) if isinstance(candidate, dict) else None
+        if value is None:
+            continue
+        try:
+            return int(value)
+        except (TypeError, ValueError):
+            continue
+    return None
+
 
 @router.post("/login")
 async def login(form_data: OAuth2PasswordRequestForm = Depends()) -> dict:
@@ -125,10 +145,19 @@ async def jellyseerr_login(form_data: OAuth2PasswordRequestForm = Depends()) ->
         raise HTTPException(status_code=status.HTTP_502_BAD_GATEWAY, detail=str(exc)) from exc
     if not isinstance(response, dict):
         raise HTTPException(status_code=status.HTTP_401_UNAUTHORIZED, detail="Invalid Jellyseerr credentials")
-    create_user_if_missing(form_data.username, "jellyseerr-user", role="user", auth_provider="jellyseerr")
+    jellyseerr_user_id = _extract_jellyseerr_user_id(response)
+    create_user_if_missing(
+        form_data.username,
+        "jellyseerr-user",
+        role="user",
+        auth_provider="jellyseerr",
+        jellyseerr_user_id=jellyseerr_user_id,
+    )
     user = get_user_by_username(form_data.username)
     if user and user.get("is_blocked"):
         raise HTTPException(status_code=status.HTTP_403_FORBIDDEN, detail="User is blocked")
+    if jellyseerr_user_id is not None:
+        set_user_jellyseerr_id(form_data.username, jellyseerr_user_id)
     token = create_access_token(form_data.username, "user")
     set_last_login(form_data.username)
     return {"access_token": token, "token_type": "bearer", "user": {"username": form_data.username, "role": "user"}}
@@ -143,7 +172,7 @@ async def me(current_user: dict = Depends(get_current_user)) -> dict:
 async def profile(current_user: dict = Depends(get_current_user)) -> dict:
     username = current_user.get("username") or ""
     username_norm = _normalize_username(username) if username else ""
-    stats = get_user_request_stats(username_norm)
+    stats = get_user_request_stats(username_norm, current_user.get("jellyseerr_user_id"))
     global_total = get_global_request_total()
     share = (stats.get("total", 0) / global_total) if global_total else 0
     activity_summary = get_user_activity_summary(username) if username else {}

backend/app/routers/requests.py

@@ -113,6 +113,10 @@ def _normalize_username(value: Any) -> Optional[str]:
     if not isinstance(value, str):
         return None
     normalized = value.strip().lower()
+    if not normalized:
+        return None
+    if "@" in normalized:
+        normalized = normalized.split("@", 1)[0]
     return normalized if normalized else None
 
 
@@ -164,6 +168,21 @@ def _normalize_requested_by(request_data: Any) -> Optional[str]:
         normalized = normalized.split("@", 1)[0]
     return normalized
 
+def _extract_requested_by_id(request_data: Any) -> Optional[int]:
+    if not isinstance(request_data, dict):
+        return None
+    requested_by = request_data.get("requestedBy") or request_data.get("requestedByUser")
+    if isinstance(requested_by, dict):
+        for key in ("id", "userId", "Id"):
+            value = requested_by.get(key)
+            if value is None:
+                continue
+            try:
+                return int(value)
+            except (TypeError, ValueError):
+                continue
+    return None
+
 
 def _format_upstream_error(service: str, exc: httpx.HTTPStatusError) -> str:
     response = exc.response
@@ -206,6 +225,7 @@ def _parse_request_payload(item: Dict[str, Any]) -> Dict[str, Any]:
     updated_at = item.get("updatedAt") or created_at
     requested_by = _request_display_name(item)
     requested_by_norm = _normalize_requested_by(item)
+    requested_by_id = _extract_requested_by_id(item)
     return {
         "request_id": item.get("id"),
         "media_id": media_id,
@@ -216,6 +236,7 @@ def _parse_request_payload(item: Dict[str, Any]) -> Dict[str, Any]:
         "year": year,
         "requested_by": requested_by,
         "requested_by_norm": requested_by_norm,
+        "requested_by_id": requested_by_id,
         "created_at": created_at,
         "updated_at": updated_at,
     }
@@ -577,6 +598,7 @@ async def _sync_all_requests(client: JellyseerrClient) -> int:
                 year=payload.get("year"),
                 requested_by=payload.get("requested_by"),
                 requested_by_norm=payload.get("requested_by_norm"),
+                requested_by_id=payload.get("requested_by_id"),
                 created_at=payload.get("created_at"),
                 updated_at=payload.get("updated_at"),
                 payload_json=payload_json,
@@ -714,6 +736,7 @@ async def _sync_delta_requests(client: JellyseerrClient) -> int:
                 year=payload.get("year"),
                 requested_by=payload.get("requested_by"),
                 requested_by_norm=payload.get("requested_by_norm"),
+                requested_by_id=payload.get("requested_by_id"),
                 created_at=payload.get("created_at"),
                 updated_at=payload.get("updated_at"),
                 payload_json=payload_json,
@@ -843,6 +866,7 @@ async def _prefetch_artwork_cache(
                             year=parsed.get("year"),
                             requested_by=parsed.get("requested_by"),
                             requested_by_norm=parsed.get("requested_by_norm"),
+                            requested_by_id=parsed.get("requested_by_id"),
                             created_at=parsed.get("created_at"),
                             updated_at=parsed.get("updated_at"),
                             payload_json=json.dumps(payload, ensure_ascii=True),
@@ -985,19 +1009,39 @@ def _recent_cache_stale() -> bool:
     return (datetime.now(timezone.utc) - parsed).total_seconds() > RECENT_CACHE_TTL_SECONDS
 
 
+def _parse_iso_datetime(value: Optional[str]) -> Optional[datetime]:
+    if not value:
+        return None
+    try:
+        parsed = datetime.fromisoformat(value.replace("Z", "+00:00"))
+    except ValueError:
+        return None
+    if parsed.tzinfo is None:
+        return parsed.replace(tzinfo=timezone.utc)
+    return parsed
+
+
 def _get_recent_from_cache(
     requested_by_norm: Optional[str],
+    requested_by_id: Optional[int],
     limit: int,
     offset: int,
     since_iso: Optional[str],
 ) -> List[Dict[str, Any]]:
     items = _recent_cache.get("items") or []
     results = []
+    since_dt = _parse_iso_datetime(since_iso)
     for item in items:
-        if requested_by_norm and item.get("requested_by_norm") != requested_by_norm:
-            continue
-        if since_iso and item.get("created_at") and item["created_at"] < since_iso:
+        if requested_by_id is not None:
+            if item.get("requested_by_id") != requested_by_id:
+                continue
+        elif requested_by_norm and item.get("requested_by_norm") != requested_by_norm:
             continue
+        if since_dt:
+            candidate = item.get("created_at") or item.get("updated_at")
+            item_dt = _parse_iso_datetime(candidate)
+            if not item_dt or item_dt < since_dt:
+                continue
         results.append(item)
     return results[offset : offset + limit]
 
@@ -1455,13 +1499,15 @@ async def recent_requests(
             raise HTTPException(status_code=502, detail=str(exc)) from exc
 
     username_norm = _normalize_username(user.get("username", ""))
+    requested_by_id = user.get("jellyseerr_user_id")
     requested_by = None if user.get("role") == "admin" else username_norm
+    requested_by_id = None if user.get("role") == "admin" else requested_by_id
     since_iso = None
     if days > 0:
         since_iso = (datetime.now(timezone.utc) - timedelta(days=days)).isoformat()
     if _recent_cache_stale():
         _refresh_recent_cache_from_db()
-    rows = _get_recent_from_cache(requested_by, take, skip, since_iso)
+    rows = _get_recent_from_cache(requested_by, requested_by_id, take, skip, since_iso)
     cache_mode = (runtime.artwork_cache_mode or "remote").lower()
     allow_title_hydrate = False
     allow_artwork_hydrate = client.configured()
@@ -1537,6 +1583,7 @@ async def recent_requests(
                         year=year or payload.get("year"),
                         requested_by=payload.get("requested_by"),
                         requested_by_norm=payload.get("requested_by_norm"),
+                        requested_by_id=payload.get("requested_by_id"),
                         created_at=payload.get("created_at"),
                         updated_at=payload.get("updated_at"),
                         payload_json=json.dumps(details, ensure_ascii=True),
@@ -1584,6 +1631,7 @@ async def recent_requests(
                             year=payload.get("year"),
                             requested_by=payload.get("requested_by"),
                             requested_by_norm=payload.get("requested_by_norm"),
+                            requested_by_id=payload.get("requested_by_id"),
                             created_at=payload.get("created_at"),
                             updated_at=payload.get("updated_at"),
                             payload_json=json.dumps(details, ensure_ascii=True),
@@ -1656,8 +1704,14 @@ async def search_requests(
             status_label = _status_label(status)
         elif isinstance(media_info_id, int):
             username_norm = _normalize_username(user.get("username", ""))
+            requested_by_id = user.get("jellyseerr_user_id")
             requested_by = None if user.get("role") == "admin" else username_norm
-            cached = get_cached_request_by_media_id(media_info_id, requested_by_norm=requested_by)
+            requested_by_id = None if user.get("role") == "admin" else requested_by_id
+            cached = get_cached_request_by_media_id(
+                media_info_id,
+                requested_by_norm=requested_by,
+                requested_by_id=requested_by_id,
+            )
             if cached:
                 request_id = cached.get("request_id")
                 status = cached.get("status")