codex 1.7.0__py3-none-any.whl → 1.7.0a0__py3-none-any.whl

codex/views/browser/filters/group.py

@@ -2,29 +2,26 @@
 
 from django.db.models import Q
 
-from codex.views.browser.params import BrowserParamsView
 from codex.views.const import (
     FILTER_ONLY_GROUP_RELATION,
     FOLDER_GROUP,
     GROUP_RELATION,
 )
+from codex.views.session import SessionView
 
-_GROUP_REL_TARGETS = frozenset({"cover", "choices"})
-_PK_REL_TARGETS = frozenset({"metadata", "mtime"})
 
-
-class GroupFilterView(BrowserParamsView):
+class GroupFilterView(SessionView):
     """Group Filters."""
 
-    SESSION_KEY = BrowserParamsView.BROWSER_SESSION_KEY
+    SESSION_KEY = SessionView.BROWSER_SESSION_KEY
 
     def _get_rel_for_pks(self, group, page_mtime=False):
         """Get the relation from the model to the pks."""
         # XXX these TARGET refs might be better as subclass get rel methods.
         target: str = self.TARGET  # type: ignore
-        if target in _GROUP_REL_TARGETS:
+        if target in ("cover", "choices"):
             rel = FILTER_ONLY_GROUP_RELATION[group]
-        elif target in _PK_REL_TARGETS or page_mtime:
+        elif target in ("metadata", "mtime") or page_mtime:
             # metadata, mtime, browser.page_mtime
             rel = "pk"
         else:
@@ -45,8 +42,8 @@ class GroupFilterView(BrowserParamsView):
             rel = self._get_rel_for_pks(group, page_mtime)
             group_filter_dict = {rel: pks}
         elif group == FOLDER_GROUP:
-            # Top folder search
             group_filter_dict = {"parent_folder": None}
         else:
             group_filter_dict = {}
+
         return Q(**group_filter_dict)

codex/views/browser/filters/search/fts.py

@@ -1,6 +1,9 @@
 """Search Filters Methods."""
 
+from django.db.models.query import Q
+
 from codex.logger.logging import get_logger
+from codex.models import Comic, StoryArc
 from codex.views.browser.filters.search.field.filter import BrowserFieldQueryFilter
 
 LOG = get_logger(__name__)
@@ -9,16 +12,27 @@ LOG = get_logger(__name__)
 class BrowserFTSFilter(BrowserFieldQueryFilter):
     """Search Filters Methods."""
 
+    @staticmethod
+    def _get_fts_filter(model, text):
+        """Get the filter dict."""
+        prefix = (
+            ""
+            if model == Comic
+            else "storyarcnumber__comic__"
+            if model == StoryArc
+            else "comic__"
+        )
+        # Custom Lookup defined in codex.models
+        rel = prefix + "comicfts__match"
+        return {rel: text}
+
     def get_fts_filter(self, model, text):
         """Perform the search and return the scores as a dict."""
         fts_filter = {}
         try:
             if text:
-                rel = self.get_rel_prefix(model)
-                # Custom lookup defined in codex.models
-                rel += "comicfts__match"
-                fts_filter[rel] = text
+                fts_filter = self._get_fts_filter(model, text)
         except Exception:
             LOG.exception("Getting Full Text Search Filter.")
             self.search_error = "Error creating full text search filter"
-        return fts_filter
+        return Q(**fts_filter)

codex/views/browser/filters/search/parse.py

@@ -1,12 +1,8 @@
 """Search Filters Methods."""
 
 import re
-from types import MappingProxyType
-
-from django.db.models.query import Q
 
 from codex.logger.logging import get_logger
-from codex.models import AdminFlag
 from codex.models.comic import ComicFTS
 from codex.views.browser.filters.search.aliases import ALIAS_FIELD_MAP
 from codex.views.browser.filters.search.fts import BrowserFTSFilter
@@ -60,43 +56,24 @@ _TOKEN_RE = re.compile(_TOKEN_REXP, flags=re.IGNORECASE)
 class SearchFilterView(BrowserFTSFilter):
     """Search Query Parser."""
 
-    ADMIN_FLAG_VALUE_KEY_MAP = MappingProxyType(
-        {
-            AdminFlag.FlagChoices.FOLDER_VIEW.value: "folder_view",
-        }
-    )
-
     def __init__(self, *args, **kwargs):
         """Initialize search variables."""
         super().__init__(*args, **kwargs)
-        self._admin_flags: MappingProxyType[str, bool] | None = None
         self.fts_mode = False
         self.search_mode = False
         self.search_error = ""
 
-    @property
-    def admin_flags(self) -> MappingProxyType[str, bool]:
-        """Set browser relevant admin flags."""
-        if self._admin_flags is None:
-            if self.ADMIN_FLAG_VALUE_KEY_MAP:
-                admin_pairs = AdminFlag.objects.filter(
-                    key__in=self.ADMIN_FLAG_VALUE_KEY_MAP.keys()
-                ).values_list("key", "on")
-            else:
-                admin_pairs = ()
-            admin_flags = {}
-            for key, on in admin_pairs:
-                export_key = self.ADMIN_FLAG_VALUE_KEY_MAP[key]
-                admin_flags[export_key] = on
-            self._admin_flags = MappingProxyType(admin_flags)
-        return self._admin_flags
-
     def _is_path_column_allowed(self):
         """Is path column allowed."""
-        return self.is_admin or bool(self.admin_flags["folder_view"])
+        if not self.is_admin():  # type: ignore
+            if not "folder_view" not in self.admin_flags:  # type: ignore
+                # Ensure admin flags for Cover View
+                self.set_admin_flags()  # type: ignore
+            return bool(self.admin_flags.get("folder_view"))  # type: ignore
+        return True
 
     @staticmethod
-    def _is_column_operators_used(exp) -> bool:
+    def _is_column_operators_used(exp):
         """Detect column expression operators, but not inside quotes."""
         for match in _COLUMN_EXPRESSION_OPERATORS_RE.finditer(exp):
             if match.group("star"):
@@ -172,7 +149,7 @@ class SearchFilterView(BrowserFTSFilter):
         field_exclude_q_list = []
         for preop, field_token_pairs in field_tokens_dict.items():
             if preop == "not":
-                exclude_q_list, include_q_list = self.get_search_field_filters(
+                exclude_q_list, filter_q_list = self.get_search_field_filters(
                     model, field_token_pairs
                 )
             else:
@@ -180,44 +157,37 @@ class SearchFilterView(BrowserFTSFilter):
                 # XXX cannot do OR queries with MATCH, it decontextualizes MATCH somehow.
                 if preop == "or":
                     self.search_error = "OR preceding column tokens with operator expressions will act as AND"
-                include_q_list, exclude_q_list = self.get_search_field_filters(
+                filter_q_list, exclude_q_list = self.get_search_field_filters(
                     model, field_token_pairs
                 )
-            field_filter_q_list += include_q_list
+            field_filter_q_list += filter_q_list
             field_exclude_q_list += exclude_q_list
+        fts_filter = self.get_fts_filter(model, fts_text)
+        return field_exclude_q_list, field_filter_q_list, fts_filter
 
-        fts_filter_dict = self.get_fts_filter(model, fts_text)
-        if fts_filter_dict:
-            self.fts_mode = True
-            fts_q = Q(**fts_filter_dict)
-        else:
-            fts_q = Q()
-
-        return field_filter_q_list, field_exclude_q_list, fts_q
-
-    def _create_search_filter(self, filter_list):
+    def _apply_search_filter_list(self, qs, filter_list, exclude):
         """Apply search filter lists. Separate filter clauses are employed for m2m searches."""
-        combined_q = Q()
         for q in filter_list:
             if not q:
                 continue
-            combined_q &= q
+            qs = qs.exclude(q) if exclude else qs.filter(q)
             self.search_mode = True
 
-        return combined_q
+        return qs
 
-    def get_search_filters(self, model):
+    def apply_search_filter(self, qs, model):
         """Preparse search, search and return the filter and scores."""
-        include_q = Q()
-        exclude_q = Q()
-        fts_q = Q()
         try:
-            field_filter_q_list, field_exclude_q_list, fts_q = (
+            field_exclude_q_list, field_filter_q_list, fts_filter = (
                 self._create_search_filters(model)
             )
+
             # Apply filters
-            include_q = self._create_search_filter(field_filter_q_list)
-            exclude_q = self._create_search_filter(field_exclude_q_list)
+            qs = self._apply_search_filter_list(qs, field_exclude_q_list, True)
+            qs = self._apply_search_filter_list(qs, field_filter_q_list, False)
+            if fts_filter:
+                qs = qs.filter(fts_filter)
+                self.search_mode = self.fts_mode = True
 
         except Exception as exc:
             msg = "Creating search filters"
@@ -225,7 +195,7 @@ class SearchFilterView(BrowserFTSFilter):
             msg = f"{msg} - {exc}"
             self.search_error = msg
 
-        return include_q, exclude_q, fts_q
+        return qs
 
     def _is_search_results_limited(self) -> bool:
         """Get search result limit from params."""

codex/views/browser/metadata.py

@@ -0,0 +1,332 @@
+"""View for marking comics read and unread."""
+
+from types import MappingProxyType
+
+from django.db.models import Count, IntegerField, Sum, Value
+from drf_spectacular.utils import extend_schema
+from rest_framework.exceptions import NotFound
+from rest_framework.response import Response
+
+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.models.functions import JsonGroupArray
+from codex.serializers.browser.metadata import PREFETCH_PREFIX, MetadataSerializer
+from codex.serializers.browser.settings import BrowserFilterChoicesInputSerilalizer
+from codex.views.browser.annotations import BrowserAnnotationsView
+from codex.views.const import METADATA_GROUP_RELATION
+
+LOG = get_logger(__name__)
+_ADMIN_OR_FILE_VIEW_ENABLED_COMIC_VALUE_FIELDS = frozenset({"path"})
+_COMIC_VALUE_FIELDS_CONFLICTING = frozenset(
+    {
+        "created_at",
+        "name",
+        "path",
+        "updated_at",
+    }
+)
+_DISABLED_VALUE_FIELD_NAMES = frozenset(
+    {"id", "pk", "sort_name", "stat"} | _COMIC_VALUE_FIELDS_CONFLICTING
+)
+_COMIC_VALUE_FIELD_NAMES = frozenset(
+    # contains path
+    field.name
+    for field in Comic._meta.get_fields()
+    if not field.is_relation and field.name not in _DISABLED_VALUE_FIELD_NAMES
+)
+_COMIC_VALUE_FIELDS_CONFLICTING_PREFIX = "conflict_"
+_COMIC_RELATED_VALUE_FIELDS = frozenset({"series__volume_count", "volume__issue_count"})
+_PATH_GROUPS = frozenset({"c", "f"})
+_CONTRIBUTOR_RELATIONS = ("role", "person")
+_SUM_FIELDS = frozenset({"page_count", "size"})
+_GROUP_RELS = MappingProxyType(
+    {
+        "i": ("publisher",),
+        "s": (
+            "publisher",
+            "imprint",
+        ),
+        "v": (
+            "publisher",
+            "imprint",
+            "series",
+        ),
+        "c": ("publisher", "imprint", "series", "volume"),
+    }
+)
+
+
+class MetadataView(BrowserAnnotationsView):
+    """Comic metadata."""
+
+    serializer_class = MetadataSerializer
+    input_serializer_class = BrowserFilterChoicesInputSerilalizer
+    TARGET = "metadata"
+    ADMIN_FLAG_VALUE_KEY_MAP = MappingProxyType(
+        {
+            AdminFlag.FlagChoices.FOLDER_VIEW.value: "folder_view",
+        }
+    )
+
+    def init_request(self):
+        """Initialize request."""
+        self.set_admin_flags()
+        self.parse_params()
+        self.set_model()
+        self.set_rel_prefix()
+
+    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,)
+
+    def _get_comic_value_fields(self):
+        """Include the path field for staff."""
+        fields = set(_COMIC_VALUE_FIELD_NAMES)
+        group = self.kwargs["group"]
+        if (
+            not (self.admin_flags["folder_view"] and self.is_admin())
+            or group not in _PATH_GROUPS
+        ):
+            fields -= _ADMIN_OR_FILE_VIEW_ENABLED_COMIC_VALUE_FIELDS
+        return tuple(fields)
+
+    def _intersection_annotate(
+        self,
+        querysets,
+        fields,
+        related_suffix="",
+        annotation_prefix="",
+    ):
+        """Annotate the intersection of value and fk fields."""
+        (filtered_qs, qs) = querysets
+
+        for field in fields:
+            # Annotate variant counts
+            # If 1 variant, annotate value, otherwise None
+            ann_field = annotation_prefix + field.replace("__", "_")
+
+            full_field = self.rel_prefix + field
+
+            if field in _SUM_FIELDS:
+                val = Sum(full_field)
+            else:
+                # group_by makes the filter work, but prevents its
+                # use as a subquery in the big query.
+                sq = filtered_qs.alias(
+                    filter_count=Count(full_field, distinct=True)
+                ).filter(filter_count=1)
+                sq = self.add_group_by(sq)
+                sq = sq.values_list(full_field + related_suffix, flat=True)
+                try:
+                    val = sq[0]
+                except IndexError:
+                    val = None
+                if field.endswith("count"):
+                    output_field = IntegerField()
+                else:
+                    output_field = Comic._meta.get_field(field).__class__()
+                val = Value(val, output_field)
+            qs = qs.annotate(**{ann_field: val})
+
+        return filtered_qs, qs
+
+    def _annotate_values_and_fks(self, qs, filtered_qs):
+        """Annotate comic values and comic foreign key values."""
+        # Simple Values
+        querysets = (filtered_qs, qs)
+        if not self.is_model_comic:
+            comic_value_fields = self._get_comic_value_fields()
+            querysets = self._intersection_annotate(querysets, comic_value_fields)
+
+            # Conflicting Simple Values
+            querysets = self._intersection_annotate(
+                querysets,
+                _COMIC_VALUE_FIELDS_CONFLICTING,
+                annotation_prefix=_COMIC_VALUE_FIELDS_CONFLICTING_PREFIX,
+            )
+
+        # Foreign Keys with special count values
+        _, qs = self._intersection_annotate(
+            querysets,
+            _COMIC_RELATED_VALUE_FIELDS,
+        )
+        return qs
+
+    def _query_groups(self):
+        """Query the through models to show group lists."""
+        groups = {}
+        if not self.model:
+            return groups
+        group = self.kwargs["group"]
+        rel = METADATA_GROUP_RELATION.get(group)
+        if not rel:
+            return groups
+        rel = rel + "__in"
+        pks = self.kwargs["pks"]
+        group_filter = {rel: pks}
+
+        for field_name in _GROUP_RELS.get(group, ()):
+            field = self.model._meta.get_field(field_name)
+            model = field.related_model
+            if not model:
+                continue
+
+            qs = model.objects.filter(**group_filter)
+            qs = qs.only("name").distinct()
+            qs = qs.group_by("name")
+            qs = qs.annotate(ids=JsonGroupArray("id", distinct=True))
+            qs = qs.values("ids", "name")
+            groups[field_name] = qs
+        return groups
+
+    @staticmethod
+    def _get_optimized_m2m_query(key, qs):
+        if key == "contributors":
+            qs = qs.prefetch_related(*_CONTRIBUTOR_RELATIONS)
+            qs = qs.only(*_CONTRIBUTOR_RELATIONS)
+        elif key == "story_arc_numbers":
+            qs = qs.select_related("story_arc")
+            qs = qs.only("story_arc", "number")
+        elif key == "identifiers":
+            qs = qs.select_related("identifier_type")
+            qs = qs.only("identifier_type", "nss", "url")
+        else:
+            qs = qs.only("name")
+        return qs
+
+    def _query_m2m_intersections(self, filtered_qs):
+        """Query the through models to figure out m2m intersections."""
+        # Speed ok, but still does a query per m2m model
+        m2m_intersections = {}
+        pk_field = self.rel_prefix + "pk"
+        comic_pks = filtered_qs.values_list(pk_field, flat=True)
+        comic_pks_count = comic_pks.count()
+        for field_name in COMIC_M2M_FIELD_NAMES:
+            model = Comic._meta.get_field(field_name).related_model
+            if not model:
+                reason = f"No model found for comic field: {field_name}"
+                raise ValueError(reason)
+
+            intersection_qs = model.objects.filter(comic__pk__in=comic_pks)
+            intersection_qs = intersection_qs.alias(count=Count("comic")).filter(
+                count=comic_pks_count
+            )
+            intersection_qs = self._get_optimized_m2m_query(field_name, intersection_qs)
+
+            m2m_intersections[field_name] = intersection_qs
+        return m2m_intersections
+
+    def _path_security(self, obj):
+        """Secure filesystem information for acl situation."""
+        group = self.kwargs["group"]
+        is_path_group = group in _PATH_GROUPS
+        if is_path_group:
+            if self.is_admin():
+                return
+            if self.admin_flags["folder_view"]:
+                obj.path = obj.search_path()
+        else:
+            obj.path = ""
+
+    def _highlight_current_group(self, obj):
+        """Values for highlighting the current group."""
+        if self.model and not self.is_model_comic:
+            # move the name of the group to the correct field
+            field = self.model.__name__.lower() + "_list"
+            group_list = self.model.objects.filter(pk__in=obj.ids).values("name")
+            setattr(obj, field, group_list)
+            obj.name = None
+
+    @classmethod
+    def _copy_m2m_intersections(cls, obj, m2m_intersections):
+        """Copy the m2m intersections into the object."""
+        # XXX It might even be faster to copy everything to a dict and not use the obj.
+        for key, qs in m2m_intersections.items():
+            serializer_key = (
+                f"{PREFETCH_PREFIX}{key}"
+                if key in ("identifiers", "contributors", "story_arc_numbers")
+                else key
+            )
+            if hasattr(obj, serializer_key):
+                # real db fields need to use their special set method.
+                field = getattr(obj, serializer_key)
+                field.set(
+                    qs,
+                    clear=True,
+                )
+            else:
+                # fake db field is just a queryset attached.
+                setattr(obj, serializer_key, qs)
+
+    @staticmethod
+    def _copy_groups(obj, groups):
+        for field, group_qs in groups.items():
+            setattr(obj, field + "_list", group_qs)
+
+    @staticmethod
+    def _copy_conflicting_simple_fields(obj):
+        for field in _COMIC_VALUE_FIELDS_CONFLICTING:
+            """Copy conflicting fields over naturral fields."""
+            conflict_field = _COMIC_VALUE_FIELDS_CONFLICTING_PREFIX + field
+            val = getattr(obj, conflict_field)
+            setattr(obj, field, val)
+
+    def _copy_annotations_into_comic_fields(self, obj, groups, m2m_intersections):
+        """Copy a bunch of values that i couldn't fit cleanly in the main queryset."""
+        self._path_security(obj)
+        self._highlight_current_group(obj)
+        self._copy_groups(obj, groups)
+        self._copy_m2m_intersections(obj, m2m_intersections)
+        if not self.is_model_comic:
+            self._copy_conflicting_simple_fields(obj)
+
+        return obj
+
+    def _raise_not_found(self, exc=None):
+        """Raise an exception if the object is not found."""
+        pks = self.kwargs["pks"]
+        group = self.kwargs["group"]
+        detail = f"Filtered metadata for {group}/{pks} not found"
+        raise NotFound(detail=detail) from exc
+
+    def get_object(self):
+        """Create a comic-like object from the current browser group."""
+        # Comic model goes through the same code path as groups because
+        # values dicts don't copy relations to the serializer. The values
+        # dict is necessary because of the folders view union in browser.py.
+
+        qs = self.get_filtered_queryset(self.model)
+
+        filtered_qs = qs
+        qs = self.annotate_order_aggregates(qs, self.model)
+        qs = self.annotate_card_aggregates(qs, self.model)
+        qs = self._annotate_values_and_fks(qs, filtered_qs)
+        qs = self.add_group_by(qs)
+
+        try:
+            obj = qs[0]
+            if not obj:
+                reason = "Empty obj"
+                raise ValueError(reason)  # noqa TRY301
+        except (IndexError, ValueError) as exc:
+            self._raise_not_found(exc)
+
+        groups = self._query_groups()
+        m2m_intersections = self._query_m2m_intersections(filtered_qs)
+        return self._copy_annotations_into_comic_fields(obj, groups, m2m_intersections)  # type: ignore
+
+    @extend_schema(parameters=[input_serializer_class])
+    def get(self, *_args, **_kwargs):
+        """Get metadata for a filtered browse group."""
+        # Init
+        try:
+            self.init_request()
+            obj = self.get_object()
+            serializer = self.get_serializer(obj)
+            return Response(serializer.data)
+        except Exception:
+            LOG.exception(f"Getting metadata {self.kwargs}")

codex/views/browser/mtime.py

@@ -7,13 +7,13 @@ from codex.logger.logging import get_logger
 from codex.models.groups import Publisher
 from codex.serializers.browser.mtime import GroupsMtimeSerializer, MtimeSerializer
 from codex.util import max_none
-from codex.views.browser.group_mtime import BrowserGroupMtimeView
+from codex.views.browser.filters.annotations import BrowserAnnotationsFilterView
 from codex.views.const import GROUP_MODEL_MAP
 
 LOG = get_logger(__name__)
 
 
-class MtimeView(BrowserGroupMtimeView):
+class MtimeView(BrowserAnnotationsFilterView):
     """Get the mtimes for the submitted groups."""
 
     input_serializer_class = GroupsMtimeSerializer
@@ -22,6 +22,11 @@ class MtimeView(BrowserGroupMtimeView):
     REPARSE_JSON_FIELDS = frozenset({"groups", "filters"})
     TARGET = "mtime"
 
+    def __init__(self, *args, **kwargs) -> None:
+        """Initialize."""
+        super().__init__(*args, **kwargs)
+        self.init_bookmark_data()
+
     def _get_group_mtime(self, item):
         """Get one group's mtimes."""
         group = item["group"]
@@ -45,6 +50,9 @@ class MtimeView(BrowserGroupMtimeView):
     @extend_schema(parameters=[GroupsMtimeSerializer])
     def get(self, *args, **kwargs):
         """Get the mtimes for the submitted groups."""
+        # Parse Request
+        self.parse_params()
+
         max_mtime = self.get_max_groups_mtime()
 
         # Serialize Response

codex/views/browser/order_by.py

@@ -1,29 +1,27 @@
 """Base view for ordering the query."""
 
+from django.db.models.aggregates import Max, Min
+
 from codex.models import Comic
-from codex.views.browser.group_mtime import BrowserGroupMtimeView
+from codex.views.browser.filters.annotations import (
+    BrowserAnnotationsFilterView,
+)
 
 
-class BrowserOrderByView(BrowserGroupMtimeView):
+class BrowserOrderByView(BrowserAnnotationsFilterView):
     """Base class for views that need ordering."""
 
-    def __init__(self, *args, **kwargs):
-        """Initialize memoized vars."""
-        super().__init__(*args, **kwargs)
-        self._order_key: str = ""
-        self._comic_sort_names: tuple[str, ...] = ()
-
-    @property
-    def order_key(self):
+    def set_order_key(self):
         """Get the default order key for the view."""
-        if not self._order_key:
-            order_key: str = self.params["order_by"]
-            if (order_key == "search_score" and not self.fts_mode) or (
-                order_key == "filename" and not self.admin_flags["folder_view"]
-            ):
-                order_key = "sort_name"
-            self._order_key = order_key
-        return self._order_key
+        order_key: str = self.params["order_by"]
+        if order_key == "search_score" and not self.fts_mode:
+            # if no search scores, use sort_name, asc
+            order_key = "sort_name"
+            order_reverse = False
+        else:
+            order_reverse = self.params.get("order_reverse")
+        self.order_key = order_key
+        self.order_agg_func = Max if order_reverse else Min
 
     def _add_comic_order_by(self, order_key, comic_sort_names):
         """Order by for comics (and covers)."""
@@ -31,7 +29,7 @@ class BrowserOrderByView(BrowserGroupMtimeView):
             order_key = self.order_key
         if order_key == "sort_name":
             if not comic_sort_names:
-                comic_sort_names = self._comic_sort_names
+                comic_sort_names = self.comic_sort_names  # type: ignore
             order_fields_head = [
                 *comic_sort_names,
                 "issue_number",
@@ -47,13 +45,15 @@ class BrowserOrderByView(BrowserGroupMtimeView):
             if order_key == "story_arc_number":
                 order_fields_head += ["date"]
             elif order_key == "bookmark_updated_at":
-                order_fields_head += ["bookmark_updated_at"]
+                order_fields_head += ["updated_at"]
         return order_fields_head
 
-    def add_order_by(self, qs, order_key="", do_reverse=True, comic_sort_names=None):
+    def add_order_by(
+        self, qs, model, order_key="", do_reverse=True, comic_sort_names=None
+    ):
         """Create the order_by list."""
         order_fields_head = ()
-        if qs.model is Comic:
+        if model == Comic:
             order_fields_head = self._add_comic_order_by(order_key, comic_sort_names)
         else:
             order_fields_head = ["order_value"]