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

codex/views/browser/choices.py

@@ -1,9 +1,7 @@
 """View for marking comics read and unread."""
 
 from types import MappingProxyType
-from typing import ClassVar
 
-import pycountry
 from caseconverter import snakecase
 from django.db.models import QuerySet
 from drf_spectacular.utils import extend_schema
@@ -11,71 +9,62 @@ from rest_framework.response import Response
 
 from codex.logger.logging import get_logger
 from codex.models import (
-    BrowserGroupModel,
     Comic,
     ContributorPerson,
-    Folder,
-    Imprint,
-    Publisher,
-    Series,
     StoryArc,
-    Volume,
 )
 from codex.models.named import IdentifierType
-from codex.serializers.browser.choices import CHOICES_SERIALIZER_CLASS_MAP
+from codex.serializers.browser.choices import (
+    BrowserChoicesFilterSerializer,
+)
 from codex.serializers.browser.filters import (
     BrowserFilterChoicesSerializer,
-    CharListField,
 )
-from codex.serializers.models.pycountry import PyCountrySerializer
-from codex.views.auth import IsAuthenticatedOrEnabledNonUsers
-from codex.views.browser.base import BrowserBaseView
+from codex.serializers.browser.settings import BrowserFilterChoicesInputSerilalizer
+from codex.serializers.choices import DUMMY_NULL_NAME, VUETIFY_NULL_CODE
+from codex.views.browser.filters.annotations import (
+    BrowserAnnotationsFilterView,
+)
 
 LOG = get_logger(__name__)
 
 _FIELD_TO_REL_MODEL_MAP = MappingProxyType(
     {
-        BrowserBaseView.CONTRIBUTOR_PERSON_UI_FIELD: (
+        BrowserAnnotationsFilterView.CONTRIBUTOR_PERSON_UI_FIELD: (
             "contributors__person",
             ContributorPerson,
         ),
-        BrowserBaseView.STORY_ARC_UI_FIELD: ("story_arc_numbers__story_arc", StoryArc),
-        BrowserBaseView.IDENTIFIER_TYPE_UI_FIELD: (
+        BrowserAnnotationsFilterView.STORY_ARC_UI_FIELD: (
+            "story_arc_numbers__story_arc",
+            StoryArc,
+        ),
+        BrowserAnnotationsFilterView.IDENTIFIER_TYPE_UI_FIELD: (
             "identifiers__identifier_type",
             IdentifierType,
         ),
     }
 )
+_BACK_REL_MAP = MappingProxyType(
+    {
+        ContributorPerson: "contributor__",
+        StoryArc: "storyarcnumber__",
+        IdentifierType: "identifier__",
+    }
+)
+_NULL_NAMED_ROW = MappingProxyType({"pk": VUETIFY_NULL_CODE, "name": DUMMY_NULL_NAME})
 
 
-class BrowserChoicesViewBase(BrowserBaseView):
+class BrowserChoicesViewBase(BrowserAnnotationsFilterView):
     """Get choices for filter dialog."""
 
-    permission_classes: ClassVar[list] = [IsAuthenticatedOrEnabledNonUsers]  # type: ignore
-
-    _CONTRIBUTORS_PERSON_REL = "contributors__person"
-    _STORY_ARC_REL = "story_arc_numbers__story_arc"
-    _IDENTIFIERS_REL = "identifiers__identifier_type"
-    _NULL_NAMED_ROW = MappingProxyType({"pk": -1, "name": "_none_"})
-    _BACK_REL_MAP = MappingProxyType(
-        {
-            ContributorPerson: "contributor__",
-            StoryArc: "storyarcnumber__",
-            IdentifierType: "identifier__",
-        }
-    )
-    _REL_MAP = MappingProxyType(
-        {
-            Publisher: "publisher",
-            Imprint: "imprint",
-            Series: "series",
-            Volume: "volume",
-            Comic: "pk",
-            Folder: "parent_folder",
-            StoryArc: "story_arc_numbers__story_arc",
-            IdentifierType: "identifiers__identifier_type",
-        }
-    )
+    input_serializer_class = BrowserFilterChoicesInputSerilalizer
+    TARGET = "choices"
+
+    def init_request(self):
+        """Initialieze request."""
+        self.parse_params()
+        self.set_model()
+        self.set_rel_prefix()
 
     @staticmethod
     def get_field_choices_query(comic_qs, field_name):
@@ -88,21 +77,13 @@ class BrowserChoicesViewBase(BrowserBaseView):
 
     def get_m2m_field_query(self, model, comic_qs: QuerySet):
         """Get distinct m2m value objects for the relation."""
-        if self.model is None:
-            LOG.error("No model to make filter choices!")
-            m2m_filter = {}
-        else:
-            model_rel: str = self._REL_MAP[self.model]  # type: ignore
-            back_rel = self._BACK_REL_MAP.get(model, "")
-            back_rel += "comic__"
-            back_rel += model_rel
-            back_rel += "__in"
-            m2m_filter = {back_rel: comic_qs}
+        back_rel = _BACK_REL_MAP.get(model, "")
+        m2m_filter = {f"{back_rel}comic__in": comic_qs}
         return model.objects.filter(**m2m_filter).values("pk", "name").distinct()
 
     @staticmethod
     def does_m2m_null_exist(comic_qs, rel):
-        """Get if null values exists for an m2m field."""
+        """Get if comics exist in the filter without values exists for an m2m field."""
         return comic_qs.filter(**{f"{rel}__isnull": True}).exists()
 
     def get_rel_and_model(self, field_name):
@@ -117,24 +98,19 @@ class BrowserChoicesViewBase(BrowserBaseView):
             rel = field_name
             model = remote_field.model if remote_field else None
 
-        rel = self.rel_prefix + rel
-
         return rel, model
 
     def get_object(self):
         """Get the comic subquery use for the choices."""
-        search_scores = self.get_search_scores()
-        if search_scores is None:
-            return self.model.objects.none()  # type: ignore
-        object_filter = self.get_query_filters(self.model, search_scores, True)
-        return self.model.objects.filter(object_filter)  # type: ignore
+        return self.get_filtered_queryset(Comic)
 
-    def _set_model(self):
-        """Set the model to query."""
-        group = self.kwargs["group"]
-        if group == self.ROOT_GROUP:
-            group = self.params.get("top_group", "p")
-        self.model: BrowserGroupModel | Comic | None = self.GROUP_MODEL_MAP[group]  # type: ignore
+    @extend_schema(parameters=[input_serializer_class])
+    def get(self, *_args, **_kwargs):
+        """Return choices."""
+        self.init_request()
+        obj = self.get_object()
+        serializer = self.get_serializer(obj)
+        return Response(serializer.data)
 
 
 class BrowserChoicesAvailableView(BrowserChoicesViewBase):
@@ -145,11 +121,14 @@ class BrowserChoicesAvailableView(BrowserChoicesViewBase):
     @classmethod
     def _get_field_choices_count(cls, comic_qs, field_name):
         """Create a pk:name object for fields without tables."""
-        return cls.get_field_choices_query(comic_qs, field_name).count()
+        qs = cls.get_field_choices_query(comic_qs, field_name)
+        return qs.count()
 
     def _get_m2m_field_choices_count(self, model, comic_qs, rel):
         """Get choices with nulls where there are nulls."""
-        count = self.get_m2m_field_query(model, comic_qs).count()
+        m2m_qs = self.get_m2m_field_query(model, comic_qs)
+        m2m_qs = m2m_qs.values("pk")
+        count = m2m_qs.count()
 
         # Detect if there are null choices.
         # Regretabbly with another query, but doing a forward query
@@ -160,14 +139,10 @@ class BrowserChoicesAvailableView(BrowserChoicesViewBase):
 
         return count
 
-    @extend_schema(request=BrowserBaseView.input_serializer_class)
-    def get(self, *_args, **_kwargs):
-        """Return all choices with more than one choice."""
-        self.parse_params()
-        self._set_model()
-        self.set_rel_prefix(self.model)
-        comic_qs = self.get_object()
-
+    def get_object(self):
+        """Get choice counts."""
+        qs = super().get_object()
+        filters = self.params.get("filters", {})
         data = {}
         for field_name in self.serializer_class().get_fields():  # type: ignore
             if field_name == "story_arcs" and self.model == StoryArc:
@@ -176,43 +151,23 @@ class BrowserChoicesAvailableView(BrowserChoicesViewBase):
             rel, m2m_model = self.get_rel_and_model(field_name)
 
             if m2m_model:
-                count = self._get_m2m_field_choices_count(m2m_model, comic_qs, rel)
+                count = self._get_m2m_field_choices_count(m2m_model, qs, rel)
             else:
-                count = self._get_field_choices_count(comic_qs, rel)
+                count = self._get_field_choices_count(qs, rel)
 
-            filters = self.params.get("filters", {})
             try:
-                flag = count > 1 or field_name in filters  # type: ignore
+                is_filter_set = bool(filters.get(field_name))
+                flag = is_filter_set or count > 1  # type: ignore
             except TypeError:
                 flag = False
             data[field_name] = flag
-
-        serializer = self.get_serializer(data)
-        return Response(serializer.data)
+        return data
 
 
 class BrowserChoicesView(BrowserChoicesViewBase):
     """Get choices for filter dialog."""
 
-    # serializer_class = Dynamic class determined in get()
-
-    def _get_field_choices(self, comic_qs, field_name):
-        """Create a pk:name object for fields without tables."""
-        qs = self.get_field_choices_query(comic_qs, field_name)
-
-        if field_name == "country":
-            lookup = pycountry.countries
-        elif field_name == "language":
-            lookup = pycountry.languages
-        else:
-            lookup = None
-
-        choices = []
-        for val in qs:
-            name = PyCountrySerializer.lookup_name(lookup, val) if lookup else val
-            choices.append({"pk": val, "name": name})
-
-        return choices
+    serializer_class = BrowserChoicesFilterSerializer
 
     def _get_m2m_field_choices(self, model, comic_qs, rel):
         """Get choices with nulls where there are nulls."""
@@ -224,7 +179,7 @@ class BrowserChoicesView(BrowserChoicesViewBase):
         # rows. :(
         if self.does_m2m_null_exist(comic_qs, rel):
             choices = list(qs)
-            choices.append(self._NULL_NAMED_ROW)
+            choices.append(_NULL_NAMED_ROW)
         else:
             choices = qs
         return choices
@@ -233,26 +188,18 @@ class BrowserChoicesView(BrowserChoicesViewBase):
         field_name = self.kwargs.get("field_name", "")
         return snakecase(field_name)
 
-    def get_serializer_class(self):  # type: ignore
-        """Dynamic serializer class."""
-        field_name = self._get_field_name()
-        return CHOICES_SERIALIZER_CLASS_MAP.get(field_name, CharListField)
-
-    @extend_schema(request=BrowserBaseView.input_serializer_class)
-    def get(self, *_args, **_kwargs):
-        """Return all choices with more than one choice."""
-        self.parse_params()
-        self._set_model()
-        self.set_rel_prefix(self.model)
-
+    def get_object(self):
+        """Return choices with more than one choice."""
+        qs = super().get_object()
         field_name = self._get_field_name()
         rel, m2m_model = self.get_rel_and_model(field_name)
 
-        comic_qs = self.get_object()
         if m2m_model:
-            choices = self._get_m2m_field_choices(m2m_model, comic_qs, rel)
+            choices = self._get_m2m_field_choices(m2m_model, qs, rel)
         else:
-            choices = self._get_field_choices(comic_qs, rel)
+            choices = self.get_field_choices_query(qs, field_name)
 
-        serializer = self.get_serializer(choices, many=True)
-        return Response(serializer.data)
+        return {
+            "field_name": field_name,
+            "choices": choices,
+        }

codex/views/browser/cover.py

@@ -0,0 +1,165 @@
+"""Comic cover thumbnail view."""
+
+from django.db.models.query import Q
+from django.http.response import StreamingHttpResponse
+from drf_spectacular.types import OpenApiTypes
+from drf_spectacular.utils import extend_schema
+from rest_framework.renderers import BaseRenderer
+
+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.models import Comic, Volume
+from codex.models.groups import Folder
+from codex.models.paths import CustomCover
+from codex.serializers.browser.settings import BrowserCoverInputSerializer
+from codex.views.browser.annotations import BrowserAnnotationsView
+from codex.views.const import (
+    CUSTOM_COVER_GROUP_RELATION,
+    GROUP_RELATION,
+    MISSING_COVER_FN,
+    MISSING_COVER_NAME_MAP,
+    STATIC_IMG_PATH,
+)
+from codex.views.util import chunker
+
+LOG = get_logger(__name__)
+
+
+class WEBPRenderer(BaseRenderer):
+    """Render WEBP images."""
+
+    media_type = "image/webp"
+    format = "webp"
+    charset = None
+    render_style = "binary"
+
+    def render(self, data, *_args, **_kwargs):
+        """Return raw data."""
+        return data
+
+
+class CoverView(BrowserAnnotationsView):
+    """ComicCover View."""
+
+    input_serializer_class = BrowserCoverInputSerializer
+    renderer_classes = (WEBPRenderer,)
+    content_type = "image/webp"
+    TARGET = "cover"
+    REPARSE_JSON_FIELDS = frozenset(
+        BrowserAnnotationsView.REPARSE_JSON_FIELDS | {"parent"}
+    )
+
+    def get_group_filter(self, group=None, pks=None, page_mtime=False):
+        """Get group filter for First Cover View."""
+        if self.params.get("dynamic_covers") or self.model in (Volume, Folder):
+            return super().get_group_filter(group=group, pks=pks, page_mtime=page_mtime)
+
+        # First cover group filter relies on sort names to look outside the browser supplied pks
+        # For multi_groups not in the browser query.
+        pks = self.kwargs["pks"]
+        qs = self.model.objects.filter(pk__in=pks)  # type: ignore
+        sort_names = qs.values_list("sort_name", flat=True).distinct()
+        model_rel = GROUP_RELATION[self.model_group]
+        group_filter = {f"{model_rel}__sort_name__in": sort_names}
+
+        parent = self.params.get("parent", {})
+        if parent_pks := parent.get("pks"):
+            parent_rel = GROUP_RELATION[parent["group"]]
+            group_filter[f"{parent_rel}__pk__in"] = parent_pks
+        return Q(**group_filter)
+
+    def get_model_group(self):
+        """Return the url group."""
+        return self.kwargs["group"]
+
+    def init_request(self):
+        """Initialize request."""
+        self.parse_params()
+        self.set_model()
+
+    def _get_comic_cover(self):
+        pks = self.kwargs["pks"]
+        return pks[0], False
+
+    def _get_custom_cover(self):
+        """Get Custom Cover."""
+        if self.model == Volume or not self.params.get("custom_covers"):
+            return None
+        group = self.kwargs["group"]
+        group_rel = CUSTOM_COVER_GROUP_RELATION[group]
+        pks = self.kwargs["pks"]
+        comic_filter = {f"{group_rel}__in": pks}
+        qs = CustomCover.objects.filter(**comic_filter)
+        qs = qs.only("pk")
+        return qs.first()
+
+    def _get_dynamic_cover(self):
+        """Get dynamic cover."""
+        self.set_order_key()
+        comic_qs = self.get_filtered_queryset(Comic)
+        comic_qs = self.annotate_order_aggregates(comic_qs, Comic)
+        comic_qs = self.add_order_by(comic_qs, Comic)
+        comic_qs = comic_qs.only("pk")
+        group_by = self.get_group_by(Comic)
+        comic_qs.group_by(group_by)
+        comic = comic_qs.first()
+        cover_pk = comic.pk if comic else 0
+        return cover_pk, False
+
+    def _get_cover_pk(self) -> tuple[int, bool]:
+        """Get Cover Pk queryset for comic queryset."""
+        if self.model == Comic:
+            cover_pk, custom = self._get_comic_cover()
+        elif custom_cover := self._get_custom_cover():
+            cover_pk = custom_cover.pk
+            custom = True
+        else:
+            cover_pk, custom = self._get_dynamic_cover()
+        return cover_pk, custom
+
+    def _get_missing_cover_path(self):
+        """Get the missing cover, which is a default svg if fetched for a group."""
+        group: str = self.kwargs["group"]
+        cover_name = MISSING_COVER_NAME_MAP.get(group)
+        if cover_name:
+            cover_fn = cover_name + ".svg"
+            content_type = "image/svg+xml"
+        else:
+            cover_fn = MISSING_COVER_FN
+            content_type = "image/webp"
+        cover_path = STATIC_IMG_PATH / cover_fn
+        return cover_path, content_type
+
+    def _get_cover_data(self, pk, custom):
+        thumb_buffer = None
+        content_type = "image/webp"
+
+        cover_path = CoverPathMixin.get_cover_path(pk, custom)
+        if not cover_path.exists():
+            thumb_buffer = CoverCreateMixin.create_cover_from_path(
+                pk, cover_path, LOG, LIBRARIAN_QUEUE, custom
+            )
+            if not thumb_buffer:
+                cover_path, content_type = self._get_missing_cover_path()
+        elif cover_path.stat().st_size == 0:
+            cover_path, content_type = self._get_missing_cover_path()
+
+        cover_file = thumb_buffer if thumb_buffer else cover_path.open("rb")
+        return cover_file, content_type
+
+    @extend_schema(
+        parameters=[BrowserAnnotationsView.input_serializer_class],
+        responses={(200, content_type): OpenApiTypes.BINARY},
+    )
+    def get(self, *args, **kwargs):  # type: ignore
+        """Get comic cover."""
+        try:
+            self.init_request()
+            pk, custom = self._get_cover_pk()
+            cover_file, content_type = self._get_cover_data(pk, custom)
+
+            return StreamingHttpResponse(chunker(cover_file), content_type=content_type)
+        except Exception:
+            LOG.exception("get")

codex/views/browser/filters/annotations.py

@@ -0,0 +1,102 @@
+"""Annotations used by a filter."""
+
+from django.db.models.aggregates import Count, Max
+from django.db.models.functions import Coalesce, Greatest
+
+from codex.models.comic import Comic
+from codex.views.browser.filters.bookmark import BookmarkFilterMixin
+from codex.views.browser.validate import BrowserValidateView
+from codex.views.const import (
+    EPOCH_START_DATETIMEFIELD,
+    ONE_INTEGERFIELD,
+)
+
+
+class BrowserAnnotationsFilterView(BrowserValidateView, BookmarkFilterMixin):
+    """Annotations that also filter."""
+
+    def __init__(self, *args, **kwargs) -> None:
+        """Initialize."""
+        super().__init__(*args, **kwargs)
+        self.init_bookmark_data()
+
+    def _get_query_filters(  # noqa: PLR0913
+        self, model, group, pks, bookmark_filter, page_mtime=False, group_filter=True
+    ):
+        """Return all the filters except the group filter."""
+        # TODO all these ifs and flags are awful
+        object_filter = self.get_group_acl_filter(model)
+        if group_filter:
+            object_filter &= self.get_group_filter(group, pks, page_mtime=page_mtime)
+        object_filter &= self.get_comic_field_filter(model)
+        if bookmark_filter:
+            # not needed when used by outerrefl OuterRef is applied next
+            object_filter &= self.get_bookmark_filter(model)
+        return object_filter
+
+    def _filter_by_child_count(self, qs, model):
+        """Filter group by child count."""
+        rel = self.rel_prefix + "pk"
+        ann_name = "child_count"
+        count_func = ONE_INTEGERFIELD if model == Comic else Count(rel, distinct=True)
+        ann = {ann_name: count_func}
+        if self.TARGET == "opds2":
+            if model != Comic:
+                qs = qs.alias(**ann)
+        else:
+            qs = qs.annotate(**ann)
+        if model != Comic:
+            qs = qs.filter(**{f"{ann_name}__gt": 0})
+        return qs
+
+    def get_filtered_queryset(  # noqa: PLR0913
+        self,
+        model,
+        group=None,
+        pks=None,
+        bookmark_filter=True,
+        page_mtime=False,
+        group_filter=True,
+    ):
+        """Get a filtered queryset for the model."""
+        object_filter = self._get_query_filters(
+            model,
+            group,
+            pks,
+            bookmark_filter,
+            page_mtime=page_mtime,
+            group_filter=group_filter,
+        )
+        qs = model.objects.filter(object_filter)
+        qs = self.apply_search_filter(qs, model)
+        return self._filter_by_child_count(qs, model)
+
+    def get_group_mtime(self, model, group=None, pks=None, page_mtime=False):
+        """Get a filtered mtime for browser pages and mtime checker."""
+        qs = self.get_filtered_queryset(
+            model,
+            group=group,
+            pks=pks,
+            bookmark_filter=self.is_bookmark_filtered,
+            page_mtime=page_mtime,
+        )
+        qs = qs.annotate(max_updated_at=Max("updated_at"))
+
+        if self.is_bookmark_filtered:
+            bm_rel, bm_filter = self.get_bookmark_rel_and_filter(model)
+            qs = qs.filter(bm_filter)
+            ua_rel = bm_rel + "__updated_at"
+            mbua = Max(ua_rel)
+        else:
+            mbua = EPOCH_START_DATETIMEFIELD
+        qs = qs.annotate(max_bookmark_updated_at=mbua)
+
+        mtime = qs.aggregate(
+            max=Greatest(
+                Coalesce("max_bookmark_updated_at", EPOCH_START_DATETIMEFIELD),
+                "max_updated_at",
+            )
+        )["max"]
+        if mtime == NotImplemented:
+            mtime = None
+        return mtime

codex/views/browser/filters/bookmark.py

@@ -1,16 +1,21 @@
 """Bookmark filter view methods."""
 
+from typing import TYPE_CHECKING
+
 from django.db.models import Q
 
-from codex.serializers.choices import CHOICES
+if TYPE_CHECKING:
+    from codex.models import BrowserGroupModel
 
 
 class BookmarkFilterMixin:
     """BookmarkFilter view methods."""
 
-    _BOOKMARK_FILTERS = frozenset(set(CHOICES["bookmarkFilter"].keys()) - {"ALL"})
+    def init_bookmark_data(self):
+        """Initialize the bm_annotation_data."""
+        self._bm_annotation_data: dict[BrowserGroupModel, tuple[str, Q]] = {}
 
-    def get_bm_rel(self, model):
+    def _get_bm_rel(self, model):
         """Create bookmark relation."""
         rel_prefix = self.get_rel_prefix(model)  # type: ignore
         return rel_prefix + "bookmark"
@@ -26,13 +31,24 @@ class BookmarkFilterMixin:
             }
         return Q(**my_bookmarks_kwargs)
 
+    def get_bookmark_rel_and_filter(self, model):
+        """Get the bookmark rel and filter once."""
+        if model not in self._bm_annotation_data:
+            bm_rel = self._get_bm_rel(model)
+            bm_filter = self._get_my_bookmark_filter(bm_rel)
+            self._bm_annotation_data[model] = (bm_rel, bm_filter)
+        return self._bm_annotation_data[model]
+
     def get_bookmark_filter(self, model):
         """Build bookmark query."""
-        choice = self.params["filters"].get("bookmark", "ALL")  # type: ignore
-        if choice in self._BOOKMARK_FILTERS:
-            bm_rel = self.get_bm_rel(model)
-            my_bookmark_filter = self._get_my_bookmark_filter(bm_rel)
-            if choice in ("UNREAD", "IN_PROGRESS"):
+        choice: str = self.params.get("filters", {}).get("bookmark", "")  # type: ignore
+        if choice:
+            bm_rel, my_bookmark_filter = self.get_bookmark_rel_and_filter(model)
+            if choice == "READ":
+                bookmark_filter = my_bookmark_filter & Q(
+                    **{f"{bm_rel}__finished": True}
+                )
+            else:
                 my_not_finished_filter = my_bookmark_filter & Q(
                     **{f"{bm_rel}__finished__in": (False, None)}
                 )
@@ -42,10 +58,6 @@ class BookmarkFilterMixin:
                     bookmark_filter = my_not_finished_filter & Q(
                         **{f"{bm_rel}__page__gt": 0}
                     )
-            else:  # READ
-                bookmark_filter = my_bookmark_filter & Q(
-                    **{f"{bm_rel}__finished": True}
-                )
         else:
             bookmark_filter = Q()
         return bookmark_filter

codex/views/browser/filters/field.py

@@ -4,18 +4,19 @@ 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.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):
     """Comic field filters."""
 
     def _filter_by_comic_field(self, field, rel_prefix):
@@ -36,9 +37,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