codex 1.5.17__py3-none-any.whl → 1.6.0__py3-none-any.whl

codex/views/admin/library.py

@@ -2,20 +2,20 @@
 
 from pathlib import Path
 from time import time
-from typing import ClassVar
 
 from django.core.cache import cache
+from django.db.utils import NotSupportedError
 from drf_spectacular.utils import extend_schema
 from rest_framework.exceptions import ValidationError
-from rest_framework.generics import GenericAPIView
-from rest_framework.permissions import IsAdminUser
 from rest_framework.response import Response
-from rest_framework.viewsets import ModelViewSet
 
 from codex.librarian.mp_queue import LIBRARIAN_QUEUE
 from codex.librarian.notifier.tasks import LIBRARY_CHANGED_TASK
 from codex.librarian.tasks import DelayedTasks
-from codex.librarian.watchdog.tasks import WatchdogPollLibrariesTask, WatchdogSyncTask
+from codex.librarian.watchdog.tasks import (
+    WatchdogPollLibrariesTask,
+    WatchdogSyncTask,
+)
 from codex.logger.logging import get_logger
 from codex.models import FailedImport, Folder, Library
 from codex.serializers.admin import (
@@ -24,31 +24,28 @@ from codex.serializers.admin import (
     FailedImportSerializer,
     LibrarySerializer,
 )
+from codex.views.admin.auth import AdminGenericAPIView, AdminModelViewSet
 
 LOG = get_logger(__name__)
 
 
-class AdminLibraryViewSet(ModelViewSet):
+class AdminLibraryViewSet(AdminModelViewSet):
     """Admin Library Viewset."""
 
-    permission_classes: ClassVar[list] = [IsAdminUser]  # type: ignore
+    _WATCHDOG_SYNC_FIELDS = frozenset({"events", "poll", "pollEvery"})
+
     queryset = Library.objects.prefetch_related("groups").defer(
         "update_in_progress", "created_at", "updated_at"
     )
     serializer_class = LibrarySerializer
 
-    WATCHDOG_SYNC_FIELDS = frozenset({"events", "poll", "pollEvery"})
-
-    def _create_library_folder(self, library):
-        folder = Folder(
-            library=library, path=library.path, name=Path(library.path).name
-        )
-        folder.save()
-
-    @staticmethod
-    def _sync_watchdog():
-        task = DelayedTasks(time() + 2, (WatchdogSyncTask(),))
-        LIBRARIAN_QUEUE.put(task)
+    @classmethod
+    def _sync_watchdog(cls, validated_keys=None):
+        if validated_keys is None or validated_keys.intersection(
+            cls._WATCHDOG_SYNC_FIELDS
+        ):
+            task = DelayedTasks(time() + 2, (WatchdogSyncTask(),))
+            LIBRARIAN_QUEUE.put(task)
 
     @staticmethod
     def _on_change():
@@ -56,25 +53,22 @@ class AdminLibraryViewSet(ModelViewSet):
         task = LIBRARY_CHANGED_TASK
         LIBRARIAN_QUEUE.put(task)
 
+    def _create_library_folder(self, library):
+        folder = Folder(
+            library=library, path=library.path, name=Path(library.path).name
+        )
+        folder.save()
+
     @staticmethod
     def _poll(pk, force):
         task = WatchdogPollLibrariesTask(frozenset({pk}), force)
         LIBRARIAN_QUEUE.put(task)
 
-    def perform_update(self, serializer):
-        """Perform update an run hooks."""
-        validated_keys = set(serializer.validated_data.keys())
-        super().perform_update(serializer)
-        if "groupSet" in validated_keys:
-            self._on_change()
-        if validated_keys.intersection(self.WATCHDOG_SYNC_FIELDS):
-            self._sync_watchdog()
-        pk = self.kwargs.get("pk")
-        self._poll(pk, False)
-
     def perform_create(self, serializer):
         """Perform create and run hooks."""
         super().perform_create(serializer)
+        if serializer.validated_data.get("covers_only"):
+            raise NotSupportedError
         library = Library.objects.only("pk", "path").get(
             path=serializer.validated_data["path"]
         )
@@ -82,25 +76,38 @@ class AdminLibraryViewSet(ModelViewSet):
         self._sync_watchdog()
         self._poll(library.pk, False)
 
+    def perform_update(self, serializer):
+        """Perform update an run hooks."""
+        validated_keys = frozenset(serializer.validated_data.keys())
+        pk = self.kwargs["pk"]
+        library = Library.objects.get(pk=pk)
+        if library.covers_only and serializer.validated_data.get("path"):
+            raise NotSupportedError
+        super().perform_update(serializer)
+        if "groupSet" in validated_keys:
+            self._on_change()
+        self._sync_watchdog(validated_keys)
+        self._poll(pk, False)
+
     def perform_destroy(self, instance):
         """Perform destroy and run hooks."""
+        if instance.covers_only:
+            raise NotSupportedError
         super().perform_destroy(instance)
         self._sync_watchdog()
         self._on_change()
 
 
-class AdminFailedImportViewSet(ModelViewSet):
+class AdminFailedImportViewSet(AdminModelViewSet):
     """Admin FailedImport Viewset."""
 
-    permission_classes: ClassVar[list] = [IsAdminUser]  # type: ignore
     queryset = FailedImport.objects.defer("updated_at")
     serializer_class = FailedImportSerializer
 
 
-class AdminFolderListView(GenericAPIView):
+class AdminFolderListView(AdminGenericAPIView):
     """List server directories."""
 
-    permission_classes: ClassVar[list] = [IsAdminUser]  # type:ignore
     serializer_class = AdminFolderListSerializer
     input_serializer_class = AdminFolderSerializer
 
@@ -108,10 +115,10 @@ class AdminFolderListView(GenericAPIView):
     def get(self, *_args, **_kwargs):
         """Get subdirectories for a path."""
         try:
-            serializer = self.input_serializer_class(data=self.request.query_params)
+            serializer = self.input_serializer_class(data=self.request.GET)
             serializer.is_valid(raise_exception=True)
-            path = Path(serializer.validated_data.get("path", "."))
-            show_hidden = serializer.validated_data.get("show_hidden", False)
+            path = Path(serializer.validated_data.get("path", "."))  # type: ignore
+            show_hidden = serializer.validated_data.get("show_hidden", False)  # type: ignore
             root_path = path.resolve()
 
             dirs = []

codex/views/admin/stats.py

@@ -6,110 +6,47 @@ from types import MappingProxyType
 from typing import ClassVar
 
 from caseconverter import snakecase
-from django.contrib.auth.models import Group, User
 from django.contrib.sessions.models import Session
 from django.db.models import Count
 from drf_spectacular.utils import extend_schema
-from rest_framework.generics import GenericAPIView
 from rest_framework.response import Response
 
 from codex.logger.logging import get_logger
 from codex.models import (
-    AgeRating,
-    Character,
     Comic,
-    Contributor,
-    ContributorPerson,
-    ContributorRole,
-    Country,
-    Folder,
-    Genre,
-    Identifier,
-    IdentifierType,
-    Imprint,
-    Language,
     Library,
-    Location,
-    OriginalFormat,
-    Publisher,
-    ScanInfo,
-    Series,
-    SeriesGroup,
-    StoryArc,
-    StoryArcNumber,
-    Tag,
-    Tagger,
-    Team,
     Timestamp,
-    Volume,
 )
 from codex.permissions import HasAPIKeyOrIsAdminUser
 from codex.serializers.admin import AdminStatsRequestSerializer, AdminStatsSerializer
 from codex.version import VERSION
+from codex.views.admin.auth import AdminGenericAPIView
+from codex.views.const import CONFIG_MODELS, METADATA_MODELS, STATS_GROUP_MODELS
 
 LOG = get_logger(__name__)
+_KEY_MODELS_MAP = MappingProxyType(
+    {
+        "config": CONFIG_MODELS,
+        "groups": STATS_GROUP_MODELS,
+        "metadata": METADATA_MODELS,
+    }
+)
+_DOCKERENV_PATH = Path("/.dockerenv")
+_CGROUP_PATH = Path("/proc/self/cgroup")
 
 
-class AdminStatsView(GenericAPIView):
+class AdminStatsView(AdminGenericAPIView):
     """Admin Flag Viewset."""
 
     permission_classes: ClassVar[list] = [HasAPIKeyOrIsAdminUser]  # type: ignore
     serializer_class = AdminStatsSerializer
     input_serializer_class = AdminStatsRequestSerializer
 
-    _GROUP_MODELS = (
-        Publisher,
-        Imprint,
-        Series,
-        Volume,
-        Comic,
-        Folder,
-    )
-    _METADATA_MODELS = (
-        AgeRating,
-        Character,
-        Country,
-        Genre,
-        Identifier,
-        IdentifierType,
-        Language,
-        Location,
-        OriginalFormat,
-        SeriesGroup,
-        ScanInfo,
-        StoryArc,
-        StoryArcNumber,
-        Team,
-        Tag,
-        Tagger,
-        Contributor,
-        ContributorPerson,
-        ContributorRole,
-    )
-    _CONFIG_MODELS = (
-        Library,
-        User,
-        Group,
-        Session,
-    )
-    _KEY_MODELS_MAP = MappingProxyType(
-        {
-            "config": _CONFIG_MODELS,
-            "groups": _GROUP_MODELS,
-            "metadata": _METADATA_MODELS,
-        }
-    )
-    _DOCKERENV_PATH = Path("/.dockerenv")
-    _CGROUP_PATH = Path("/proc/self/cgroup")
-
     @classmethod
     def _is_docker(cls):
         """Test if we're in a docker container."""
         try:
-            return (
-                cls._DOCKERENV_PATH.is_file()
-                or "docker" in cls._CGROUP_PATH.read_text()
-            )
+            return _DOCKERENV_PATH.is_file() or "docker" in _CGROUP_PATH.read_text()
         except Exception:
             return False
 
@@ -125,7 +62,7 @@ class AdminStatsView(GenericAPIView):
     def _get_models(self, key):
         """Get models from request params."""
         request_model_list = self.request.GET.get(key)
-        all_models = self._KEY_MODELS_MAP[key]
+        all_models = _KEY_MODELS_MAP[key]
         if request_model_list:
             models = []
             for model_name in request_model_list.split(","):
@@ -150,7 +87,10 @@ class AdminStatsView(GenericAPIView):
 
             vnp_name = snakecase(title)
             vnp_name += "_count"
-            obj[vnp_name] = model.objects.count()
+            qs = model.objects
+            if model == Library:
+                qs = qs.filter(covers_only=False)
+            obj[vnp_name] = qs.count()
         return obj
 
     @staticmethod
@@ -232,15 +172,12 @@ class AdminStatsView(GenericAPIView):
             self._get_metadata(obj)
         return obj
 
-    @extend_schema(
-        parameters=[input_serializer_class],
-        request=input_serializer_class,
-    )
+    @extend_schema(parameters=[input_serializer_class])
     def get(self, *_args, **_kwargs):
         """Get the stats object and serialize it."""
         input_serializer = self.input_serializer_class(data=self.request.GET)
         input_serializer.is_valid()
-        self.params = frozenset(input_serializer.validated_data.get("params", {}))
+        self.params = frozenset(input_serializer.validated_data.get("params", {}))  # type: ignore
 
         obj = self.get_object()
         serializer = self.get_serializer(obj)

codex/views/admin/tasks.py

@@ -1,22 +1,24 @@
 """Librarian Status View."""
 
 from types import MappingProxyType
-from typing import ClassVar
+from typing import TYPE_CHECKING
 
 from drf_spectacular.utils import extend_schema
-from rest_framework.permissions import IsAdminUser
 from rest_framework.response import Response
-from rest_framework.views import APIView
-from rest_framework.viewsets import ReadOnlyModelViewSet
 
 from codex.librarian.covers.tasks import (
     CoverCreateAllTask,
     CoverRemoveAllTask,
     CoverRemoveOrphansTask,
 )
+from codex.librarian.importer.tasks import (
+    AdoptOrphanFoldersTask,
+    UpdateGroupsTask,
+)
 from codex.librarian.janitor.tasks import (
     ForceUpdateAllFailedImportsTask,
     JanitorBackupTask,
+    JanitorCleanCoversTask,
     JanitorCleanFKsTask,
     JanitorCleanupSessionsTask,
     JanitorClearStatusTask,
@@ -36,30 +38,36 @@ from codex.librarian.search.tasks import (
     SearchIndexRemoveStaleTask,
     SearchIndexUpdateTask,
 )
-from codex.librarian.watchdog.tasks import WatchdogPollLibrariesTask, WatchdogSyncTask
+from codex.librarian.watchdog.tasks import (
+    WatchdogPollLibrariesTask,
+    WatchdogSyncTask,
+)
 from codex.logger.logging import get_logger
 from codex.models import LibrarianStatus
 from codex.serializers.admin import AdminLibrarianTaskSerializer
 from codex.serializers.mixins import OKSerializer
 from codex.serializers.models.admin import LibrarianStatusSerializer
+from codex.views.admin.auth import AdminAPIView, AdminReadOnlyModelViewSet
+from codex.views.const import EPOCH_START
+
+if TYPE_CHECKING:
+    from collections.abc import Mapping
 
 LOG = get_logger(__name__)
 
 
-class AdminLibrarianStatusViewSet(ReadOnlyModelViewSet):
+class AdminLibrarianStatusViewSet(AdminReadOnlyModelViewSet):
     """Librarian Task Statuses."""
 
-    permission_classes: ClassVar[list] = [IsAdminUser]  # type: ignore
     queryset = LibrarianStatus.objects.filter(active__isnull=False).order_by(
         "active", "pk"
     )
     serializer_class = LibrarianStatusSerializer
 
 
-class AdminLibrarianTaskView(APIView):
+class AdminLibrarianTaskView(AdminAPIView):
     """Queue Librarian Jobs."""
 
-    permission_classes: ClassVar[list] = [IsAdminUser]  # type: ignore
     input_serializer_class = AdminLibrarianTaskSerializer
     serializer_class = OKSerializer
 
@@ -86,6 +94,7 @@ class AdminLibrarianTaskView(APIView):
             "notify_library_changed": LIBRARY_CHANGED_TASK,
             "notify_librarian_status": LIBRARIAN_STATUS_TASK,
             "cleanup_fks": JanitorCleanFKsTask(),
+            "cleanup_db_custom_covers": JanitorCleanCoversTask(),
             "cleanup_sessions": JanitorCleanupSessionsTask(),
             "cleanup_covers": CoverRemoveOrphansTask(),
             "librarian_clear_status": JanitorClearStatusTask(),
@@ -93,6 +102,8 @@ class AdminLibrarianTaskView(APIView):
             "poll": WatchdogPollLibrariesTask(frozenset(), False),
             "poll_force": WatchdogPollLibrariesTask(frozenset(), True),
             "janitor_nightly": JanitorNightlyTask(),
+            "force_update_groups": UpdateGroupsTask(start_time=EPOCH_START),
+            "adopt_folders": AdoptOrphanFoldersTask(),
         }
     )
 
@@ -109,10 +120,13 @@ class AdminLibrarianTaskView(APIView):
     @extend_schema(request=input_serializer_class)
     def post(self, *_args, **_kwargs):
         """Download a comic archive."""
-        serializer = self.input_serializer_class(data=self.request.data)
+        # DRF does not populate POST correctly, only data
+        data = self.request.data  # type:ignore
+        serializer = self.input_serializer_class(data=data)
         serializer.is_valid(raise_exception=True)
-        task_name = serializer.validated_data.get("task")
-        pk = serializer.validated_data.get("library_id")
+        validated_data: Mapping = serializer.validated_data  # type: ignore
+        task_name = validated_data.get("task")
+        pk = validated_data.get("library_id")
         task = self._get_task(task_name, pk)
         if task:
             LIBRARIAN_QUEUE.put(task)

codex/views/admin/user.py

@@ -1,30 +1,24 @@
 """Admin User ViewSet."""
 
-from typing import ClassVar
-
 from django.contrib.auth.models import User
 from django.contrib.auth.password_validation import validate_password
 from django.core.cache import cache
 from django.core.exceptions import ValidationError
-from django.db.models import F
-from rest_framework.generics import GenericAPIView
-from rest_framework.permissions import IsAdminUser
 from rest_framework.response import Response
 from rest_framework.status import HTTP_202_ACCEPTED, HTTP_400_BAD_REQUEST
-from rest_framework.viewsets import ModelViewSet
 
 from codex.librarian.mp_queue import LIBRARIAN_QUEUE
 from codex.librarian.notifier.tasks import LIBRARY_CHANGED_TASK
 from codex.logger.logging import get_logger
 from codex.serializers.admin import UserChangePasswordSerializer, UserSerializer
+from codex.views.admin.auth import AdminGenericAPIView, AdminModelViewSet
 
 LOG = get_logger(__name__)
 
 
-class AdminUserViewSet(ModelViewSet):
+class AdminUserViewSet(AdminModelViewSet):
     """User ViewSet."""
 
-    permission_classes: ClassVar[list] = [IsAdminUser]  # type: ignore
     queryset = User.objects.prefetch_related("groups").defer(
         "first_name", "last_name", "email"
     )
@@ -55,15 +49,10 @@ class AdminUserViewSet(ModelViewSet):
         super().perform_update(serializer)
         self._on_change()
 
-    def get_queryset(self):
-        """Annotate last active."""
-        return self.queryset.annotate(last_active=F("useractive__updated_at"))
-
 
-class AdminUserChangePasswordView(GenericAPIView):
+class AdminUserChangePasswordView(AdminGenericAPIView):
     """Special View to hash user password."""
 
-    permission_classes: ClassVar[list] = [IsAdminUser]  # type: ignore
     serializer_class = UserChangePasswordSerializer
 
     def put(self, request, *args, **kwargs):

codex/views/auth.py

@@ -1,24 +1,19 @@
 """Views authorization."""
 
-from types import MappingProxyType
-
-from django.conf import settings
-from django.contrib.auth.models import AnonymousUser, Group
+from django.contrib.auth.models import AnonymousUser
 from django.db.models import Q
 from drf_spectacular.utils import extend_schema
 from rest_framework.generics import GenericAPIView
-from rest_framework.mixins import RetrieveModelMixin
 from rest_framework.permissions import IsAuthenticated
 from rest_framework.response import Response
+from rest_framework.views import APIView
 
 from codex.logger.logging import get_logger
 from codex.models import AdminFlag, Comic, Folder, StoryArc, UserActive
-from codex.serializers.auth import AuthAdminFlagsSerializer, TimezoneSerializer
-from codex.serializers.choices import CHOICES
+from codex.serializers.auth import TimezoneSerializer
 from codex.serializers.mixins import OKSerializer
 
 LOG = get_logger(__name__)
-NULL_USER = {"pk": None, "username": None, "is_staff": False}
 
 
 class IsAuthenticatedOrEnabledNonUsers(IsAuthenticated):
@@ -36,20 +31,33 @@ class IsAuthenticatedOrEnabledNonUsers(IsAuthenticated):
         return super().has_permission(request, view)
 
 
-class TimezoneView(GenericAPIView):
+class AuthMixin:
+    """General Auth Policy."""
+
+    permission_classes = (IsAuthenticatedOrEnabledNonUsers,)
+
+
+class AuthAPIView(AuthMixin, APIView):
+    """Auth Policy APIView."""
+
+
+class AuthGenericAPIView(AuthMixin, GenericAPIView):
+    """Auth Policy GenericAPIView."""
+
+
+class TimezoneView(AuthGenericAPIView):
     """User info."""
 
     input_serializer_class = TimezoneSerializer
     serializer_class = OKSerializer
 
-    _AUTH_USER_MODEL_TYPE = type(settings.AUTH_USER_MODEL)
-
     @extend_schema(request=input_serializer_class)
-    def post(self, request, *args, **kwargs):
+    def put(self, request, *args, **kwargs):
         """Get the user info for the current user."""
-        serializer = self.input_serializer_class(data=self.request.data)
+        data = self.request.data  # type: ignore
+        serializer = self.input_serializer_class(data=data)
         serializer.is_valid(raise_exception=True)
-        request.session["django_timezone"] = serializer.validated_data["timezone"]
+        request.session["django_timezone"] = serializer.validated_data["timezone"]  # type: ignore
         request.session.save()
         user = self.request.user
         if user.is_authenticated:
@@ -58,52 +66,11 @@ class TimezoneView(GenericAPIView):
         return Response(serializer.data)
 
 
-class AdminFlagsView(GenericAPIView, RetrieveModelMixin):
-    """Get admin flags relevant to auth."""
-
-    _ADMIN_FLAG_KEYS = frozenset(
-        (
-            AdminFlag.FlagChoices.NON_USERS.value,
-            AdminFlag.FlagChoices.REGISTRATION.value,
-        )
-    )
-
-    serializer_class = AuthAdminFlagsSerializer
-    queryset = AdminFlag.objects.filter(key__in=_ADMIN_FLAG_KEYS).only("key", "on")
-
-    def get_object(self):
-        """Get admin flags."""
-        flags = {}
-        for obj in self.get_queryset():  # type: ignore
-            name = CHOICES["admin"]["adminFlags"][obj.key].lower().replace(" ", "_")
-            flags[name] = obj.on
-        return flags
-
-    def get(self, request, *args, **kwargs):
-        """Get admin flags relevant to auth."""
-        return self.retrieve(request, *args, **kwargs)
-
-
 class GroupACLMixin:
     """Filter group ACLS for views."""
 
-    ROOT_GROUP = "r"
-    FOLDER_GROUP = "f"
-    STORY_ARC_GROUP = "a"
-    COMIC_GROUP = "c"
-    GROUP_RELATION = MappingProxyType(
-        {
-            "p": "publisher",
-            "i": "imprint",
-            "s": "series",
-            "v": "volume",
-            COMIC_GROUP: "pk",
-            FOLDER_GROUP: "parent_folder",
-            STORY_ARC_GROUP: "story_arc_numbers__story_arc",
-        }
-    )
-
-    def get_rel_prefix(self, model):
+    @staticmethod
+    def get_rel_prefix(model):
         """Return the relation prfiex for most fields."""
         prefix = ""
         if model != Comic:
@@ -124,14 +91,22 @@ class GroupACLMixin:
         user = self.request.user  # type: ignore
 
         if user and not isinstance(user, AnonymousUser):
-            groups = user.groups
             # Include groups are visible to users in the group
-            include_groups = groups.filter(groupauth__exclude=False)
-            # Exclude groups are visible to users not in the group
-            exclude_groups = Group.objects.filter(groupauth__exclude=True).exclude(
-                user=user
+            user_filter = {f"{groups_rel}__user": user}
+            exclude_rel = f"{groups_rel}__groupauth__exclude"
+            exclude_query = ~Q(**user_filter, **{exclude_rel: True})
+            include_query = Q(**user_filter, **{exclude_rel: False}) | ~Q(
+                **{exclude_rel: False}
             )
-            groups_query = include_groups | exclude_groups
-            query |= Q(**{f"{groups_rel}__in": groups_query})
+            auth_query = exclude_query & include_query
+            query |= auth_query
 
         return query
+
+
+class AuthFilterGenericAPIView(AuthGenericAPIView, GroupACLMixin):
+    """Auth Enabled GenericAPIView."""
+
+
+class AuthFilterAPIView(AuthAPIView, GroupACLMixin):
+    """Auth Enabled APIView."""