codex 1.6.0a5__py3-none-any.whl → 1.6.0a7__py3-none-any.whl

codex/views/browser/filters/field.py

@@ -4,18 +4,20 @@ from types import MappingProxyType
 
 from django.db.models import Q
 
-from codex.views.session import BrowserSessionViewBase
+from codex.models.comic import Comic
+from codex.views.browser.filters.bookmark import BookmarkFilterMixin
+from codex.views.browser.filters.group import GroupFilterView
 
 _FILTER_REL_MAP = MappingProxyType(
     {
-        BrowserSessionViewBase.CONTRIBUTOR_PERSON_UI_FIELD: "contributors__person",
-        BrowserSessionViewBase.STORY_ARC_UI_FIELD: "story_arc_numbers__story_arc",
-        BrowserSessionViewBase.IDENTIFIER_TYPE_UI_FIELD: "identifiers__identifier_type",
+        GroupFilterView.CONTRIBUTOR_PERSON_UI_FIELD: "contributors__person",
+        GroupFilterView.STORY_ARC_UI_FIELD: "story_arc_numbers__story_arc",
+        GroupFilterView.IDENTIFIER_TYPE_UI_FIELD: "identifiers__identifier_type",
     }
 )
 
 
-class ComicFieldFilter(BrowserSessionViewBase):
+class ComicFieldFilterView(GroupFilterView, BookmarkFilterMixin):
     """Comic field filters."""
 
     def _filter_by_comic_field(self, field, rel_prefix):
@@ -36,9 +38,10 @@ class ComicFieldFilter(BrowserSessionViewBase):
             filter_query |= Q(**{f"{rel}__in": filter_list})
         return filter_query
 
-    def get_comic_field_filter(self, rel_prefix):
+    def get_comic_field_filter(self, model):
         """Filter the comics based on the form filters."""
         comic_field_filter = Q()
+        rel_prefix = "" if model == Comic else self.rel_prefix  # type: ignore
         for attribute in self.FILTER_ATTRIBUTES:
             comic_field_filter &= self._filter_by_comic_field(attribute, rel_prefix)
         return comic_field_filter

codex/views/browser/filters/group.py

@@ -2,25 +2,28 @@
 
 from django.db.models import Q
 
-from codex.views.auth import GroupACLMixin
+from codex.views.const import FOLDER_GROUP, GROUP_RELATION
+from codex.views.session import SessionView
 
 
-class GroupFilterMixin(GroupACLMixin):
+class GroupFilterView(SessionView):
     """Group Filters."""
 
+    SESSION_KEY = SessionView.BROWSER_SESSION_KEY
+
     def get_group_filter(self, choices):
         """Get filter for the displayed group."""
         group = self.kwargs["group"]  # type: ignore
         pks = self.kwargs["pks"]  # type: ignore
         if pks:  # type: ignore
             group_relation = "comic__" if choices else ""
-            if choices and group == self.FOLDER_GROUP:
+            if choices and group == FOLDER_GROUP:
                 group_relation += "folders"
             else:
-                group_relation += self.GROUP_RELATION[group]
+                group_relation += GROUP_RELATION[group]
             group_relation += "__in"
             group_filter_dict = {group_relation: pks}  # type: ignore
-        elif group == self.FOLDER_GROUP:
+        elif group == FOLDER_GROUP:
             group_filter_dict = {"parent_folder": None}
         else:
             group_filter_dict = {}

codex/views/browser/filters/search.py

@@ -9,12 +9,13 @@ from codex.logger.logging import get_logger
 from codex.models import Comic
 from codex.search.query import CodexSearchQuerySet
 from codex.settings.settings import DEBUG
-from codex.views.browser.const import MAX_OBJ_PER_PAGE
+from codex.views.browser.filters.field import ComicFieldFilterView
+from codex.views.const import MAX_OBJ_PER_PAGE
 
 LOG = get_logger(__name__)
-SEARCH_SCORE_MAX = 100.0
-SEARCH_SCORE_MIN = 0.001
-SEARCH_SCORE_EMPTY = 0.0
+_SEARCH_SCORE_MAX = 100.0
+_SEARCH_SCORE_MIN = 0.001
+_SEARCH_SCORE_EMPTY = 0.0
 
 
 @dataclass
@@ -26,7 +27,7 @@ class SearchScorePks:
     next_pks: tuple[int, ...] = ()
 
 
-class SearchFilterMixin:
+class SearchFilterView(ComicFieldFilterView):
     """Search Filters Methods."""
 
     def _is_search_results_limited(self) -> bool:
@@ -154,10 +155,12 @@ class SearchFilterMixin:
                 when = {prefix + "pk": pk, "then": score}
                 whens.append(When(**when))
             if prev_pks:
-                whens.append(When(pk__in=prev_pks, then=SEARCH_SCORE_MAX))
+                whens.append(When(pk__in=prev_pks, then=_SEARCH_SCORE_MAX))
             if next_pks:
-                whens.append(When(pk__in=next_pks, then=SEARCH_SCORE_MIN))
-            search_score = self.order_agg_func(Case(*whens, default=SEARCH_SCORE_EMPTY))  # type: ignore
+                whens.append(When(pk__in=next_pks, then=_SEARCH_SCORE_MIN))
+            search_score = self.order_agg_func(  # type: ignore
+                Case(*whens, default=_SEARCH_SCORE_EMPTY)
+            )
         else:
             search_score = Value(0.0)
         return qs.annotate(search_score=search_score)

codex/views/browser/metadata.py

@@ -1,7 +1,6 @@
 """View for marking comics read and unread."""
 
 from types import MappingProxyType
-from typing import ClassVar
 
 from django.core.exceptions import FieldDoesNotExist
 from django.db.models import Count, IntegerField, Sum, Value
@@ -13,8 +12,7 @@ from codex.librarian.importer.const import COMIC_M2M_FIELD_NAMES
 from codex.logger.logging import get_logger
 from codex.models import AdminFlag, Comic
 from codex.serializers.browser.metadata import MetadataSerializer
-from codex.views.auth import IsAuthenticatedOrEnabledNonUsers
-from codex.views.browser.browser_annotations import BrowserAnnotationsView
+from codex.views.browser.annotations import BrowserAnnotationsView
 
 LOG = get_logger(__name__)
 _ADMIN_OR_FILE_VIEW_ENABLED_COMIC_VALUE_FIELDS = frozenset({"path"})
@@ -37,7 +35,7 @@ _COMIC_VALUE_FIELD_NAMES = frozenset(
 )
 _COMIC_VALUE_FIELDS_CONFLICTING_PREFIX = "conflict_"
 _COMIC_RELATED_VALUE_FIELDS = frozenset({"series__volume_count", "volume__issue_count"})
-_PATH_GROUPS = ("c", "f")
+_PATH_GROUPS = frozenset({"c", "f"})
 _CONTRIBUTOR_RELATIONS = ("role", "person")
 _SUM_FIELDS = frozenset({"page_count", "size"})
 _GROUP_RELS = frozenset({"publisher", "imprint", "series", "volume"})
@@ -46,7 +44,6 @@ _GROUP_RELS = frozenset({"publisher", "imprint", "series", "volume"})
 class MetadataView(BrowserAnnotationsView):
     """Comic metadata."""
 
-    permission_classes: ClassVar[list] = [IsAuthenticatedOrEnabledNonUsers]  # type: ignore
     serializer_class = MetadataSerializer
     TARGET = "metadata"
     ADMIN_FLAG_VALUE_KEY_MAP = MappingProxyType(
@@ -259,7 +256,6 @@ class MetadataView(BrowserAnnotationsView):
         filtered_qs = qs
         qs = self.annotate_order_aggregates(qs, self.model)
         qs = self.annotate_card_aggregates(qs, self.model)
-        qs = self.annotate_for_metadata(qs, self.model)
         group_by = self.get_group_by()
         qs = qs.group_by(group_by)
         qs = self._annotate_values_and_fks(qs, filtered_qs)
@@ -277,7 +273,7 @@ class MetadataView(BrowserAnnotationsView):
         m2m_intersections = self._query_m2m_intersections(filtered_qs)
         return self._copy_annotations_into_comic_fields(obj, m2m_intersections)  # type: ignore
 
-    def set_valid_browse_nav_groups(self, _valid_top_groups):
+    def set_valid_browse_nav_groups(self, valid_top_groups):  # noqa: ARG002
         """Limited allowed nav groups for metadata."""
         group = self.kwargs["group"]
         self.valid_nav_groups = (group,)

codex/views/browser/{browser_order_by.py → order_by.py}

@@ -6,22 +6,18 @@ from codex.models import Comic
 from codex.views.browser.filters.annotations import (
     BrowserAnnotationsFilterView,
 )
+from codex.views.const import FOLDER_GROUP
 
 
 class BrowserOrderByView(BrowserAnnotationsFilterView):
     """Base class for views that need ordering."""
 
-    def __init__(self, *args, **kwargs):
-        """Set params for the type checker."""
-        super().__init__(*args, **kwargs)
-        self.order_key: str = ""
-
     def set_order_key(self):
         """Get the default order key for the view."""
         order_key: str = self.params.get("order_by", "")  # type: ignore
         if not order_key:
             group = self.kwargs.get("group")
-            order_key = "filename" if group == self.FOLDER_GROUP else "sort_name"
+            order_key = "filename" if group == FOLDER_GROUP else "sort_name"
         self.order_key: str = order_key
         order_reverse = self.params.get("order_reverse")
         self.order_agg_func = Max if order_reverse else Min

codex/views/browser/paginate.py

@@ -0,0 +1,106 @@
+"""Browser pagination."""
+
+from math import ceil
+
+from django.core.paginator import EmptyPage, Paginator
+
+from codex.logger.logging import get_logger
+from codex.models import (
+    Comic,
+    Folder,
+)
+from codex.views.browser.annotations import BrowserAnnotationsView
+from codex.views.const import (
+    MAX_OBJ_PER_PAGE,
+)
+
+LOG = get_logger(__name__)
+
+
+class BrowserPaginateView(BrowserAnnotationsView):
+    """Browser pagination."""
+
+    def _check_page_in_bounds(self, total_count):
+        """Redirect page out of bounds."""
+        pks = self.kwargs.get("pks")
+        page = self.kwargs.get("page", 1)
+        num_pages = ceil(total_count / MAX_OBJ_PER_PAGE)
+        if (not pks and page == 1) or (page >= 1 and page <= num_pages):
+            # Don't redirect if on the root page for the group.
+            # Or page within valid range.
+            return num_pages
+
+        # Adjust route mask for redirect
+        group = self.kwargs.get("group")
+        if num_pages and page > 1:
+            # Try page 1 first.
+            new_page = num_pages if num_pages and page > num_pages else 1
+            pks = pks if pks else "0"
+        else:
+            # Redirect to root for the group.
+            pks = "0"
+            new_page = 1
+
+        reason = f"{page=} does not exist!"
+        route_changes = {"group": group, "pks": pks, "page": new_page}
+        return self.raise_redirect(reason, route_mask=route_changes)
+
+    def _paginate_section(self, model, qs, page):
+        """Paginate a group or Comic section."""
+        orphans = 0 if self.model_group == "f" or self.params.get("q") else 5
+        paginator = Paginator(qs, MAX_OBJ_PER_PAGE, orphans=orphans)
+        try:
+            qs = paginator.page(page).object_list
+        except EmptyPage:
+            if model != Folder:
+                model_name = self.model.__name__ if self.model else "NO_MODEL"
+                LOG.warning(f"No {model_name}s on page {page}")
+            qs = model.objects.none()
+
+        return qs
+
+    def _paginate_groups(self, group_qs, total_group_count):
+        """Paginate the group object list before books."""
+        if total_group_count:
+            page = self.kwargs.get("page", 1)
+            page_group_qs = self._paginate_section(self.model, group_qs, page)
+        else:
+            page_group_qs = self.model.objects.none()  # type: ignore
+        return page_group_qs
+
+    def _paginate_books(self, book_qs, total_group_count, page_obj_count):
+        """Paginate the book object list based on how many group/folders are showing."""
+        if page_obj_count >= MAX_OBJ_PER_PAGE:
+            # No books for this page
+            page_book_qs = Comic.objects.none()
+        else:
+            group_remainder = total_group_count % MAX_OBJ_PER_PAGE
+            if page_obj_count:
+                # There are books after the groups on the same page
+                # Manually add books without the paginator
+                book_limit = MAX_OBJ_PER_PAGE - group_remainder
+                page_book_qs = book_qs[:book_limit]
+            else:
+                # There are books after the groups on a new page
+                if group_remainder:
+                    book_offset = MAX_OBJ_PER_PAGE - group_remainder
+                    page_book_qs = book_qs[book_offset:]
+                else:
+                    page_book_qs = book_qs
+
+                num_group_and_mixed_pages = ceil(total_group_count / MAX_OBJ_PER_PAGE)
+                book_only_page = self.kwargs.get("page", 1) - num_group_and_mixed_pages
+                page_book_qs = self._paginate_section(
+                    Comic, page_book_qs, book_only_page
+                )
+        return page_book_qs
+
+    def paginate(self, group_qs, book_qs, group_count, book_count):
+        """Paginate the queryset into a group and book object lists."""
+        num_pages = self._check_page_in_bounds(group_count + book_count)
+        page_group_qs = self._paginate_groups(group_qs, group_count)
+        page_group_count = page_group_qs.count()
+        page_book_qs = self._paginate_books(book_qs, group_count, page_group_count)
+        page_book_count = page_book_qs.count()
+
+        return page_group_qs, page_book_qs, num_pages, page_group_count, page_book_count

codex/views/browser/{session.py → settings.py}

@@ -1,12 +1,13 @@
 """Browser session view."""
 
 from codex.serializers.browser.settings import BrowserSettingsSerializer
-from codex.views.session import BrowserSessionViewBase, SessionViewBase
+from codex.views.settings import SettingsView
 
 
-class BrowserSessionView(BrowserSessionViewBase, SessionViewBase):
+class BrowserSettingsView(SettingsView):
     """Get Browser Settings."""
 
     # Put Browser Settings is normally done through BrowserView.get()
-
     serializer_class = BrowserSettingsSerializer  # type: ignore
+
+    SESSION_KEY = SettingsView.BROWSER_SESSION_KEY

codex/views/browser/title.py

@@ -0,0 +1,48 @@
+"""Browser title."""
+
+from codex.models import BrowserGroupModel, Comic, Volume
+from codex.views.browser.breadcrumbs import BrowserBreadcrumbsView
+
+
+class BrowserTitleView(BrowserBreadcrumbsView):
+    """Browser title methods."""
+
+    def __init__(self, *args, **kwargs):
+        """Set params for the type checker."""
+        super().__init__(*args, **kwargs)
+        self.group_instance: BrowserGroupModel | None = None
+
+    def _get_root_group_name(self):
+        if not self.model:
+            reason = "No model set in browser"
+            raise ValueError(reason)
+        plural = self.model._meta.verbose_name_plural
+        if not plural:
+            reason = f"No plural name for {self.model}"
+            raise ValueError(reason)
+        return plural.capitalize(), 0
+
+    def _get_group_name(self):
+        group_count = 0
+        if gi := self.group_instance:
+            if isinstance(gi, Volume):
+                group_count = gi.series.volume_count
+            elif isinstance(gi, Comic):
+                group_count = gi.volume.issue_count
+            group_name = gi.name
+        else:
+            group_name = ""
+        return group_name, group_count
+
+    def get_browser_page_title(self):
+        """Get the proper title for this browse level."""
+        pks = self.kwargs.get("pks")
+        if not pks:
+            group_name, group_count = self._get_root_group_name()
+        else:
+            group_name, group_count = self._get_group_name()
+
+        return {
+            "group_name": group_name,
+            "group_count": group_count,
+        }

codex/views/browser/validate.py

@@ -0,0 +1,158 @@
+"""Browser Settings and URL Validation."""
+
+from copy import deepcopy
+from types import MappingProxyType
+
+from codex.exceptions import SeeOtherRedirectError
+from codex.logger.logging import get_logger
+from codex.serializers.choices import DEFAULTS
+from codex.views.browser.base import BrowserBaseView
+from codex.views.const import (
+    COMIC_GROUP,
+    FOLDER_GROUP,
+    ROOT_GROUP,
+    STORY_ARC_GROUP,
+)
+
+LOG = get_logger(__name__)
+
+
+class BrowserValidateView(BrowserBaseView):
+    """Browser Settings and URL Validation."""
+
+    DEFAULT_ROUTE = MappingProxyType(
+        {
+            "name": "browser",
+            "params": deepcopy(DEFAULTS["breadcrumbs"][0]),
+        }
+    )
+
+    def raise_redirect(self, reason, route_mask=None, settings_mask=None):
+        """Redirect the client to a valid group url."""
+        route = deepcopy(dict(self.DEFAULT_ROUTE))
+        if route_mask:
+            route["params"].update(route_mask)  # type: ignore
+        settings = deepcopy(dict(self.params))
+        if settings_mask:
+            settings.update(settings_mask)
+        detail = {"route": route, "settings": settings, "reason": reason}
+        raise SeeOtherRedirectError(detail=detail)
+
+    def _get_valid_browse_top_groups(self):
+        """Get valid top groups for the current settings.
+
+        Valid top groups are determined by the Browser Settings.
+        """
+        valid_top_groups = []
+
+        show = self.params["show"]
+        for nav_group, allowed in show.items():
+            if allowed:
+                valid_top_groups.append(nav_group)
+        # Issues is always a valid top group
+        valid_top_groups += [COMIC_GROUP]
+
+        return valid_top_groups
+
+    def _validate_top_group(self, valid_top_groups):
+        nav_group = self.kwargs.get("group")
+        top_group = self.params.get("top_group")
+        if top_group not in valid_top_groups:
+            reason = f"top_group {top_group} not in valid nav groups, changed to "
+            if nav_group in valid_top_groups:
+                valid_top_group = nav_group
+                reason += "nav group: "
+            else:
+                valid_top_group = valid_top_groups[0]
+                reason += "first valid top group "
+            reason += valid_top_group
+            pks = self.kwargs.get("pks", ())
+            page = self.kwargs["page"]
+            route = {"group": nav_group, "pks": pks, "page": page}
+            settings_mask = {"top_group": valid_top_group}
+            self.raise_redirect(reason, route, settings_mask)
+
+    def set_valid_browse_nav_groups(self, valid_top_groups):
+        """Get valid nav groups for the current settings.
+
+        Valid nav groups are the top group and below that are also
+        enabled in browser settings.
+
+        May always navigate to root 'r' nav group.
+        """
+        top_group = self.params["top_group"]
+        nav_group = self.kwargs["group"]
+        valid_nav_groups = [ROOT_GROUP]
+
+        for possible_index, possible_nav_group in enumerate(valid_top_groups):
+            if top_group == possible_nav_group:
+                # all the nav groups past this point,
+                # 'c' is obscured by the web reader url, but valid for opds
+                tail_top_groups = valid_top_groups[possible_index:]
+                valid_nav_groups += tail_top_groups
+
+                if nav_group not in valid_nav_groups:
+                    reason = (
+                        f"Nav group {nav_group} unavailable, "
+                        f"redirect to {ROOT_GROUP}"
+                    )
+                    self.raise_redirect(reason)
+                break
+        self.valid_nav_groups = tuple(valid_nav_groups)
+
+    def _validate_folder_settings(self):
+        """Check that all the view variables for folder mode are set right."""
+        # Check folder view admin flag
+        if not self.admin_flags["folder_view"]:
+            reason = "folder view disabled"
+            valid_top_groups = self._get_valid_browse_top_groups()
+            settings_mask = {"top_group": valid_top_groups[0]}
+            self.raise_redirect(reason, settings_mask=settings_mask)
+
+        valid_top_groups = (FOLDER_GROUP,)
+        self._validate_top_group(valid_top_groups)
+        self.valid_nav_groups = valid_top_groups
+
+    def _validate_browser_group_settings(self):
+        """Check that all the view variables for browser mode are set right."""
+        # Validate Browser top_group
+        # Change top_group if its not in the valid top groups
+        valid_top_groups = self._get_valid_browse_top_groups()
+        self._validate_top_group(valid_top_groups)
+
+        # Validate pks
+        nav_group = self.kwargs["group"]
+        pks = self.kwargs["pks"]
+        if nav_group == ROOT_GROUP and (pks and 0 not in pks):
+            # r never has pks
+            reason = f"Redirect r with {pks=} to pks 0"
+            self.raise_redirect(reason)
+
+        # Validate Browser nav_group
+        # Redirect if nav group is wrong
+        self.set_valid_browse_nav_groups(valid_top_groups)
+
+    def _validate_story_arc_settings(self):
+        """Validate story arc settings."""
+        valid_top_groups = (STORY_ARC_GROUP,)
+        self._validate_top_group(valid_top_groups)
+        self.valid_nav_groups = valid_top_groups
+
+    def validate_settings(self):
+        """Validate group and top group settings."""
+        group = self.kwargs["group"]
+        if group == FOLDER_GROUP:
+            self._validate_folder_settings()
+        elif group == STORY_ARC_GROUP:
+            self._validate_story_arc_settings()
+        else:
+            self._validate_browser_group_settings()
+
+        # Validate order
+        if self.order_key == "filename" and not self.admin_flags["folder_view"]:
+            pks = self.kwargs["pks"]
+            page = self.kwargs["page"]
+            route_changes = {"group": group, "pks": pks, "page": page}
+            reason = "order by filename not allowed by admin flag."
+            settings_mask = {"order_by": "sort_name"}
+            self.raise_redirect(reason, route_changes, settings_mask)

codex/views/const.py

@@ -2,6 +2,38 @@
 
 from types import MappingProxyType
 
+from django.contrib.auth.models import Group, User
+from django.contrib.sessions.models import Session
+
+from codex.models import (
+    AgeRating,
+    BrowserGroupModel,
+    Character,
+    Comic,
+    Contributor,
+    ContributorPerson,
+    ContributorRole,
+    Country,
+    Folder,
+    Genre,
+    Identifier,
+    IdentifierType,
+    Imprint,
+    Language,
+    Library,
+    Location,
+    OriginalFormat,
+    Publisher,
+    ScanInfo,
+    Series,
+    SeriesGroup,
+    StoryArc,
+    StoryArcNumber,
+    Tag,
+    Tagger,
+    Team,
+    Volume,
+)
 from codex.settings.settings import CODEX_PATH
 
 FALSY = {None, "", "false", "0", False}
@@ -18,3 +50,68 @@ MISSING_COVER_NAME_MAP = MappingProxyType(
 )
 MISSING_COVER_FN = "missing-cover-165.webp"
 MISSING_COVER_PATH = STATIC_IMG_PATH / MISSING_COVER_FN
+
+
+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",
+    }
+)
+GROUP_MODEL_MAP: MappingProxyType[str, type[BrowserGroupModel] | None] = (
+    MappingProxyType(
+        {
+            ROOT_GROUP: None,
+            "p": Publisher,
+            "i": Imprint,
+            "s": Series,
+            "v": Volume,
+            COMIC_GROUP: Comic,
+            FOLDER_GROUP: Folder,
+            STORY_ARC_GROUP: StoryArc,
+        }
+    )
+)
+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,
+)
+MAX_OBJ_PER_PAGE = 100
+GROUP_MTIME_MODEL_MAP = MappingProxyType({"r": Publisher, "a": StoryArc, "f": Folder})

codex/views/cover.py

@@ -1,18 +1,17 @@
 """Comic cover thumbnail view."""
 
-from typing import ClassVar
-
 from django.http import HttpResponse
 from drf_spectacular.types import OpenApiTypes
 from drf_spectacular.utils import extend_schema
 from rest_framework.renderers import BaseRenderer
-from rest_framework.views import APIView
 
 from codex.librarian.covers.create import CoverCreateMixin
 from codex.librarian.covers.path import CoverPathMixin
 from codex.librarian.mp_queue import LIBRARIAN_QUEUE
 from codex.logger.logging import get_logger
-from codex.views.auth import GroupACLMixin, IsAuthenticatedOrEnabledNonUsers
+from codex.views.auth import (
+    AuthAPIView,
+)
 from codex.views.const import MISSING_COVER_FN, MISSING_COVER_NAME_MAP, STATIC_IMG_PATH
 
 LOG = get_logger(__name__)
@@ -31,10 +30,9 @@ class WEBPRenderer(BaseRenderer):
         return data
 
 
-class CoverView(APIView, GroupACLMixin):
+class CoverView(AuthAPIView):
     """ComicCover View."""
 
-    permission_classes: ClassVar[list] = [IsAuthenticatedOrEnabledNonUsers]  # type: ignore
     renderer_classes = (WEBPRenderer,)
     content_type = "image/webp"