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

codex/views/admin/tasks.py

@@ -1,24 +1,22 @@
 """Librarian Status View."""
 
 from types import MappingProxyType
-from typing import TYPE_CHECKING
+from typing import ClassVar
 
 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,
@@ -38,36 +36,30 @@ 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(AdminReadOnlyModelViewSet):
+class AdminLibrarianStatusViewSet(ReadOnlyModelViewSet):
     """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(AdminAPIView):
+class AdminLibrarianTaskView(APIView):
     """Queue Librarian Jobs."""
 
+    permission_classes: ClassVar[list] = [IsAdminUser]  # type: ignore
     input_serializer_class = AdminLibrarianTaskSerializer
     serializer_class = OKSerializer
 
@@ -94,7 +86,6 @@ class AdminLibrarianTaskView(AdminAPIView):
             "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(),
@@ -102,8 +93,6 @@ class AdminLibrarianTaskView(AdminAPIView):
             "poll": WatchdogPollLibrariesTask(frozenset(), False),
             "poll_force": WatchdogPollLibrariesTask(frozenset(), True),
             "janitor_nightly": JanitorNightlyTask(),
-            "force_update_groups": UpdateGroupsTask(start_time=EPOCH_START),
-            "adopt_folders": AdoptOrphanFoldersTask(),
         }
     )
 
@@ -120,13 +109,10 @@ class AdminLibrarianTaskView(AdminAPIView):
     @extend_schema(request=input_serializer_class)
     def post(self, *_args, **_kwargs):
         """Download a comic archive."""
-        # DRF does not populate POST correctly, only data
-        data = self.request.data  # type:ignore
-        serializer = self.input_serializer_class(data=data)
+        serializer = self.input_serializer_class(data=self.request.data)
         serializer.is_valid(raise_exception=True)
-        validated_data: Mapping = serializer.validated_data  # type: ignore
-        task_name = validated_data.get("task")
-        pk = validated_data.get("library_id")
+        task_name = serializer.validated_data.get("task")
+        pk = serializer.validated_data.get("library_id")
         task = self._get_task(task_name, pk)
         if task:
             LIBRARIAN_QUEUE.put(task)

codex/views/admin/user.py

@@ -1,24 +1,29 @@
 """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 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(AdminModelViewSet):
+class AdminUserViewSet(ModelViewSet):
     """User ViewSet."""
 
+    permission_classes: ClassVar[list] = [IsAdminUser]  # type: ignore
     queryset = User.objects.prefetch_related("groups").defer(
         "first_name", "last_name", "email"
     )
@@ -50,9 +55,10 @@ class AdminUserViewSet(AdminModelViewSet):
         self._on_change()
 
 
-class AdminUserChangePasswordView(AdminGenericAPIView):
+class AdminUserChangePasswordView(GenericAPIView):
     """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,19 +1,25 @@
 """Views authorization."""
 
+from types import MappingProxyType
+
+from django.conf import settings
 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 TimezoneSerializer
+from codex.serializers.auth import AuthAdminFlagsSerializer, TimezoneSerializer
+from codex.serializers.choices import CHOICES
 from codex.serializers.mixins import OKSerializer
+from codex.views.const import GROUP_NAME_MAP
 
 LOG = get_logger(__name__)
+NULL_USER = {"pk": None, "username": None, "is_staff": False}
 
 
 class IsAuthenticatedOrEnabledNonUsers(IsAuthenticated):
@@ -31,33 +37,20 @@ class IsAuthenticatedOrEnabledNonUsers(IsAuthenticated):
         return super().has_permission(request, view)
 
 
-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):
+class TimezoneView(GenericAPIView):
     """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 put(self, request, *args, **kwargs):
+    def post(self, request, *args, **kwargs):
         """Get the user info for the current user."""
-        data = self.request.data  # type: ignore
-        serializer = self.input_serializer_class(data=data)
+        serializer = self.input_serializer_class(data=self.request.data)
         serializer.is_valid(raise_exception=True)
-        request.session["django_timezone"] = serializer.validated_data["timezone"]  # type: ignore
+        request.session["django_timezone"] = serializer.validated_data["timezone"]
         request.session.save()
         user = self.request.user
         if user.is_authenticated:
@@ -66,11 +59,49 @@ class TimezoneView(AuthGenericAPIView):
         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."""
 
-    @staticmethod
-    def get_rel_prefix(model):
+    ROOT_GROUP = "r"
+    FOLDER_GROUP = "f"
+    STORY_ARC_GROUP = "a"
+    COMIC_GROUP = "c"
+    GROUP_RELATION = MappingProxyType(
+        {
+            **GROUP_NAME_MAP,
+            COMIC_GROUP: "pk",
+            FOLDER_GROUP: "parent_folder",
+            STORY_ARC_GROUP: "story_arc_numbers__story_arc",
+        }
+    )
+
+    def get_rel_prefix(self, model):
         """Return the relation prfiex for most fields."""
         prefix = ""
         if model != Comic:
@@ -102,11 +133,3 @@ class GroupACLMixin:
             query |= auth_query
 
         return query
-
-
-class AuthFilterGenericAPIView(AuthGenericAPIView, GroupACLMixin):
-    """Auth Enabled GenericAPIView."""
-
-
-class AuthFilterAPIView(AuthAPIView, GroupACLMixin):
-    """Auth Enabled APIView."""

codex/views/bookmark.py

@@ -1,47 +1,53 @@
 """Bookmark views."""
 
-from django.db.models.expressions import F
-from django.db.models.functions import Now
+from typing import ClassVar
+
 from drf_spectacular.utils import extend_schema
+from rest_framework.generics import GenericAPIView
 from rest_framework.response import Response
 
-from codex.librarian.mp_queue import LIBRARIAN_QUEUE
-from codex.librarian.notifier.tasks import NotifierTask
 from codex.logger.logging import get_logger
 from codex.models import Bookmark, Comic
 from codex.serializers.models.bookmark import (
     BookmarkFinishedSerializer,
     BookmarkSerializer,
 )
-from codex.views.auth import (
-    AuthFilterGenericAPIView,
-)
-from codex.views.const import FOLDER_GROUP, GROUP_RELATION
+from codex.views.auth import GroupACLMixin, IsAuthenticatedOrEnabledNonUsers
 
 LOG = get_logger(__name__)
 VERTICAL_READING_DIRECTIONS = frozenset({"ttb", "btt"})
-_BOOKMARK_UPDATE_FIELDS = frozenset(
-    {
+
+
+class BookmarkBaseView(GenericAPIView, GroupACLMixin):
+    """Bookmark Updater."""
+
+    _BOOKMARK_UPDATE_FIELDS = (
         "page",
         "finished",
         "fit_to",
         "two_pages",
         "reading_direction",
-    }
-)
-_COMIC_ONLY_FIELDS = ("pk", "page_count")
-
+    )
+    _BOOKMARK_ONLY_FIELDS = (*_BOOKMARK_UPDATE_FIELDS, "pk", "comic")
+    _COMIC_ONLY_FIELDS = ("pk", "page_count")
 
-class BookmarkBaseView(AuthFilterGenericAPIView):
-    """Bookmark Updater."""
+    def get_bookmark_filter(self):
+        """Get search kwargs for the reader."""
+        search_kwargs = {}
+        if self.request.user.is_authenticated:
+            search_kwargs["user"] = self.request.user
+        else:
+            if not self.request.session or not self.request.session.session_key:
+                LOG.debug("no session, make one")
+                self.request.session.save()
+            search_kwargs["session_id"] = self.request.session.session_key
+        return search_kwargs
 
-    def get_bookmark_search_kwargs(self, comic_filter=None):
+    def get_bookmark_search_kwargs(self, comic_filter):
         """Get the search kwargs for a user's authentication state."""
         search_kwargs = {}
-
-        if comic_filter:
-            for key, value in comic_filter.items():
-                search_kwargs[f"comic__{key}"] = value
+        for key, value in comic_filter.items():
+            search_kwargs[f"comic__{key}"] = value
 
         if self.request.user.is_authenticated:
             search_kwargs["user"] = self.request.user
@@ -58,9 +64,8 @@ class BookmarkBaseView(AuthFilterGenericAPIView):
         page = updates.get("page")
         if page is None:
             return
-        max_page = bm.page_count + 1
-        page = max(min(page, max_page), 0)
-        if page == max_page:
+        page = max(min(page, bm.comic.max_page), 0)
+        if page == bm.comic.max_page:
             # Auto finish on bookmark last page
             bm.finished = True
         updates["page"] = page
@@ -76,49 +81,25 @@ class BookmarkBaseView(AuthFilterGenericAPIView):
         ):
             updates["two_pages"] = None
 
-    def notify_library_changed(self):
-        """Notify one user that their library changed."""
-        if user := self.request.user:
-            uid = user.id  # type: ignore
-        else:
-            uid = self.request.session.session_key
-        group = f"user_{uid}"
-        task = NotifierTask("LIBRARY_CHANGED", group)
-        LIBRARIAN_QUEUE.put(task)
-
     def _update_bookmarks(self, search_kwargs, updates):
         """Update existing bookmarks."""
-        count = 0
-        finished = False
-        if not updates:
-            return count, finished
         group_acl_filter = self.get_group_acl_filter(Bookmark)
-        update_fields = set(updates.keys()) & _BOOKMARK_UPDATE_FIELDS
-        update_fields.add("updated_at")
-        only_fields = (*update_fields, "pk")
-        existing_bookmarks = Bookmark.objects.filter(group_acl_filter).filter(
-            **search_kwargs
+        existing_bookmarks = (
+            Bookmark.objects.filter(group_acl_filter)
+            .filter(**search_kwargs)
+            .select_related("comic")
+            .only(*self._BOOKMARK_ONLY_FIELDS)
         )
-        if updates.get("page") is not None:
-            existing_bookmarks = existing_bookmarks.annotate(
-                page_count=F("comic__page_count")
-            )
-        existing_bookmarks = existing_bookmarks.only(*only_fields)
         update_bookmarks = []
         for bm in existing_bookmarks:
             self._update_bookmarks_validate_page(bm, updates)
             self._update_bookmarks_validate_two_pages(bm, updates)
-            old_finished = bm.finished
             for key, value in updates.items():
                 setattr(bm, key, value)
-            bm.updated_at = Now()
             update_bookmarks.append(bm)
-            finished = finished or old_finished != bm.finished
-        count = len(update_bookmarks)
-        if count:
-            Bookmark.objects.bulk_update(update_bookmarks, tuple(update_fields))
-        return count, finished
-        # LOG.debug(f"Updated {count} bookmarks.")
+        if update_bookmarks:
+            update_fields = list(self._BOOKMARK_UPDATE_FIELDS | updates.keys())
+            Bookmark.objects.bulk_update(update_bookmarks, update_fields)
 
     @staticmethod
     def _create_bookmarks_validate_two_pages(updates):
@@ -131,23 +112,25 @@ class BookmarkBaseView(AuthFilterGenericAPIView):
 
     def _create_bookmarks(self, comic_filter, search_kwargs, updates):
         """Create new bookmarks for comics that don't exist yet."""
-        count = 0
-        finished = False
         self._create_bookmarks_validate_two_pages(updates)
         if not updates:
-            return count, finished
+            return
         create_bookmarks = []
         group_acl_filter = self.get_group_acl_filter(Comic)
-        exclude = {}
         for key, value in search_kwargs.items():
-            exclude["bookmark__" + key] = value
+            exclude = {"bookmark__" + key: value}
+            break
+        else:
+            reason = (
+                f"No user or session_id found for creating bookmarks: {search_kwargs}"
+            )
+            raise ValueError(reason)
         create_bookmark_comics = (
             Comic.objects.filter(group_acl_filter)
             .filter(**comic_filter)
             .exclude(**exclude)
-            .only(*_COMIC_ONLY_FIELDS)
+            .only(*self._COMIC_ONLY_FIELDS)
         )
-        finished = False
         for comic in create_bookmark_comics:
             defaults = {"comic": comic}
             defaults.update(updates)
@@ -156,43 +139,33 @@ class BookmarkBaseView(AuthFilterGenericAPIView):
                     defaults[key] = value
 
             bm = Bookmark(**defaults)
+            if updates.get("page") == comic.max_page:
+                # Auto finish on bookmark last page
+                # This almost never happens. Possibly never.
+                bm.finished = True
             create_bookmarks.append(bm)
-        count = len(create_bookmarks)
-        if count:
-            Bookmark.objects.bulk_create(
-                create_bookmarks,
-                update_fields=tuple(_BOOKMARK_UPDATE_FIELDS),
-                unique_fields=Bookmark._meta.unique_together[0],  # type: ignore
-            )
-            finished = updates.get("finished", False)
-            # LOG.debug(f"Create {count} bookmarks.")
-        return count, finished
+        Bookmark.objects.bulk_create(
+            create_bookmarks,
+            update_fields=self._BOOKMARK_UPDATE_FIELDS,
+            unique_fields=Bookmark._meta.unique_together[0],  # type: ignore
+        )
 
     def update_bookmarks(self, updates, comic_filter):
         """Update a user bookmark."""
         search_kwargs = self.get_bookmark_search_kwargs(comic_filter)
-        count, finished = self._update_bookmarks(search_kwargs, updates)
-        create_count, create_finished = self._create_bookmarks(
-            comic_filter, search_kwargs, updates
-        )
-        count += create_count
-        finished = finished or create_finished
-        if count and finished:
-            self.notify_library_changed()
+        self._update_bookmarks(search_kwargs, updates)
+        self._create_bookmarks(comic_filter, search_kwargs, updates)
 
 
 class BookmarkView(BookmarkBaseView):
     """User Bookmark View."""
 
+    permission_classes: ClassVar[list] = [IsAuthenticatedOrEnabledNonUsers]  # type:ignore
     serializer_class = BookmarkSerializer
 
-    def _parse_params(self):
+    def _validate(self, serializer_class):
         """Validate and translate the submitted data."""
-        group = self.kwargs.get("group")
-        # If the target is recursive, strip everything but finished state data.
-        serializer_class = None if group == "c" else BookmarkFinishedSerializer
-
-        data = self.request.data  # type: ignore
+        data = self.request.data
         if serializer_class:
             serializer = serializer_class(data=data, partial=True)
         else:
@@ -203,12 +176,19 @@ class BookmarkView(BookmarkBaseView):
     @extend_schema(request=serializer_class, responses=None)
     def patch(self, *_args, **_kwargs):
         """Update bookmarks recursively."""
-        updates = self._parse_params()
-
         group = self.kwargs.get("group")
+        # If the target is recursive, strip everything but finished state data.
+        serializer_class = None if group == "c" else BookmarkFinishedSerializer
+
+        updates = self._validate(serializer_class)
+
         pks = self.kwargs.get("pks")
-        rel = "folders__in" if group == FOLDER_GROUP else GROUP_RELATION[group] + "__in"
-        comic_filter = {rel: pks}
 
-        self.update_bookmarks(updates, comic_filter)
+        if group == "f":
+            relation = "folders__in"
+        else:
+            relation = self.GROUP_RELATION[group] + "__in"
+        comic_filter = {relation: pks}
+
+        self.update_bookmarks(updates, comic_filter=comic_filter)
         return Response()