codex 1.6.0a6__py3-none-any.whl → 1.6.0a8__py3-none-any.whl

codex/views/auth.py

@@ -1,25 +1,19 @@
 """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 AuthAdminFlagsSerializer, TimezoneSerializer
-from codex.serializers.choices import CHOICES
+from codex.serializers.auth import TimezoneSerializer
 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):
@@ -37,20 +31,33 @@ class IsAuthenticatedOrEnabledNonUsers(IsAuthenticated):
         return super().has_permission(request, view)
 
 
-class TimezoneView(GenericAPIView):
+class AuthMixin:
+    """General Auth Policy."""
+
+    permission_classes = (IsAuthenticatedOrEnabledNonUsers,)
+
+
+class AuthAPIView(AuthMixin, APIView):
+    """Auth Policy APIView."""
+
+
+class AuthGenericAPIView(AuthMixin, GenericAPIView):
+    """Auth Policy GenericAPIView."""
+
+
+class TimezoneView(AuthGenericAPIView):
     """User info."""
 
     input_serializer_class = TimezoneSerializer
     serializer_class = OKSerializer
 
-    _AUTH_USER_MODEL_TYPE = type(settings.AUTH_USER_MODEL)
-
     @extend_schema(request=input_serializer_class)
     def post(self, request, *args, **kwargs):
         """Get the user info for the current user."""
-        serializer = self.input_serializer_class(data=self.request.data)
+        data = self.request.data  # type: ignore
+        serializer = self.input_serializer_class(data=data)
         serializer.is_valid(raise_exception=True)
-        request.session["django_timezone"] = serializer.validated_data["timezone"]
+        request.session["django_timezone"] = serializer.validated_data["timezone"]  # type: ignore
         request.session.save()
         user = self.request.user
         if user.is_authenticated:
@@ -59,49 +66,11 @@ class TimezoneView(GenericAPIView):
         return Response(serializer.data)
 
 
-class AdminFlagsView(GenericAPIView, RetrieveModelMixin):
-    """Get admin flags relevant to auth."""
-
-    _ADMIN_FLAG_KEYS = frozenset(
-        (
-            AdminFlag.FlagChoices.NON_USERS.value,
-            AdminFlag.FlagChoices.REGISTRATION.value,
-        )
-    )
-
-    serializer_class = AuthAdminFlagsSerializer
-    queryset = AdminFlag.objects.filter(key__in=_ADMIN_FLAG_KEYS).only("key", "on")
-
-    def get_object(self):
-        """Get admin flags."""
-        flags = {}
-        for obj in self.get_queryset():  # type: ignore
-            name = CHOICES["admin"]["adminFlags"][obj.key].lower().replace(" ", "_")
-            flags[name] = obj.on
-        return flags
-
-    def get(self, request, *args, **kwargs):
-        """Get admin flags relevant to auth."""
-        return self.retrieve(request, *args, **kwargs)
-
-
 class GroupACLMixin:
     """Filter group ACLS for views."""
 
-    ROOT_GROUP = "r"
-    FOLDER_GROUP = "f"
-    STORY_ARC_GROUP = "a"
-    COMIC_GROUP = "c"
-    GROUP_RELATION = MappingProxyType(
-        {
-            **GROUP_NAME_MAP,
-            COMIC_GROUP: "pk",
-            FOLDER_GROUP: "parent_folder",
-            STORY_ARC_GROUP: "story_arc_numbers__story_arc",
-        }
-    )
-
-    def get_rel_prefix(self, model):
+    @staticmethod
+    def get_rel_prefix(model):
         """Return the relation prfiex for most fields."""
         prefix = ""
         if model != Comic:
@@ -133,3 +102,11 @@ 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,9 +1,6 @@
 """Bookmark views."""
 
-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.logger.logging import get_logger
@@ -12,13 +9,16 @@ from codex.serializers.models.bookmark import (
     BookmarkFinishedSerializer,
     BookmarkSerializer,
 )
-from codex.views.auth import GroupACLMixin, IsAuthenticatedOrEnabledNonUsers
+from codex.views.auth import (
+    AuthFilterGenericAPIView,
+)
+from codex.views.const import GROUP_RELATION
 
 LOG = get_logger(__name__)
 VERTICAL_READING_DIRECTIONS = frozenset({"ttb", "btt"})
 
 
-class BookmarkBaseView(GenericAPIView, GroupACLMixin):
+class BookmarkBaseView(AuthFilterGenericAPIView):
     """Bookmark Updater."""
 
     _BOOKMARK_UPDATE_FIELDS = (
@@ -160,12 +160,11 @@ class BookmarkBaseView(GenericAPIView, GroupACLMixin):
 class BookmarkView(BookmarkBaseView):
     """User Bookmark View."""
 
-    permission_classes: ClassVar[list] = [IsAuthenticatedOrEnabledNonUsers]  # type:ignore
     serializer_class = BookmarkSerializer
 
     def _validate(self, serializer_class):
         """Validate and translate the submitted data."""
-        data = self.request.data
+        data = self.request.data  # type: ignore
         if serializer_class:
             serializer = serializer_class(data=data, partial=True)
         else:
@@ -184,10 +183,7 @@ class BookmarkView(BookmarkBaseView):
 
         pks = self.kwargs.get("pks")
 
-        if group == "f":
-            relation = "folders__in"
-        else:
-            relation = self.GROUP_RELATION[group] + "__in"
+        relation = "folders__in" if group == "f" else GROUP_RELATION[group] + "__in"
         comic_filter = {relation: pks}
 
         self.update_bookmarks(updates, comic_filter=comic_filter)

codex/views/browser/{browser_annotations.py → annotations.py}

@@ -17,82 +17,73 @@ from django.db.models import (
     Value,
     When,
 )
+from django.db.models.aggregates import Count
 from django.db.models.fields import CharField, PositiveSmallIntegerField
 from django.db.models.functions import Least, Reverse, Right, StrIndex
 
+from codex.logger.logging import get_logger
 from codex.models import (
     BrowserGroupModel,
     Comic,
     Folder,
-    Imprint,
-    Publisher,
-    Series,
     StoryArc,
     Volume,
 )
 from codex.models.functions import JsonGroupArray
-from codex.views.browser.browser_order_by import (
+from codex.views.browser.order_by import (
     BrowserOrderByView,
 )
+from codex.views.const import STORY_ARC_GROUP
 from codex.views.mixins import SharedAnnotationsMixin
 
-_REL_MAP = MappingProxyType(
+_NONE_INTEGERFIELD = Value(None, PositiveSmallIntegerField())
+_NONE_DATETIMEFIELD = Value(None, DateTimeField())
+_ORDER_AGGREGATE_FUNCS = MappingProxyType(
+    # These are annotated to order_value because they're simple relations
     {
-        Publisher: "publisher",
-        Imprint: "imprint",
-        Series: "series",
-        Volume: "volume",
-        Folder: "parent_folder",
-        StoryArc: "story_arc_numbers__story_arc",
+        "age_rating": Avg,
+        "community_rating": Avg,
+        "created_at": Min,
+        "critical_rating": Avg,
+        "date": Min,
+        "page_count": Sum,
+        "size": Sum,
+        "updated_at": Min,
     }
 )
+_ANNOTATED_ORDER_FIELDS = frozenset(
+    # These are annotated with their own functions
+    {
+        "filename",
+        "sort_name",
+        "search_score",
+        "bookmark_updated_at",
+        "story_arc_number",
+    }
+)
+_ALTERNATE_GROUP_BY: MappingProxyType[type[BrowserGroupModel], str] = MappingProxyType(
+    {Comic: "id", Volume: "name"}
+)
+_ONE_INTEGERFIELD = Value(1, PositiveSmallIntegerField())
+
+LOG = get_logger(__name__)
 
 
 class BrowserAnnotationsView(BrowserOrderByView, SharedAnnotationsMixin):
     """Base class for views that need special metadata annotations."""
 
-    _NONE_INTEGERFIELD = Value(None, PositiveSmallIntegerField())
-    _NONE_DATETIMEFIELD = Value(None, DateTimeField())
-    _ORDER_AGGREGATE_FUNCS = MappingProxyType(
-        # These are annotated to order_value because they're simple relations
-        {
-            "age_rating": Avg,
-            "community_rating": Avg,
-            "created_at": Min,
-            "critical_rating": Avg,
-            "date": Min,
-            "page_count": Sum,
-            "size": Sum,
-            "updated_at": Min,
-        }
-    )
-    _ANNOTATED_ORDER_FIELDS = frozenset(
-        # These are annotated with their own functions
-        {
-            "filename",
-            "sort_name",
-            "search_score",
-            "bookmark_updated_at",
-            "story_arc_number",
-        }
-    )
-    _ALTERNATE_GROUP_BY: MappingProxyType[type[BrowserGroupModel], str] = (
-        MappingProxyType({Comic: "id", Volume: "name"})
-    )
-
     def __init__(self, *args, **kwargs):
         """Set params for the type checker."""
         super().__init__(*args, **kwargs)
         self.is_opds_1_acquisition = False
         self.comic_sort_names = ()
         self.bm_annotataion_data: dict[BrowserGroupModel, tuple[str, dict]] = {}
-        self.cover_search_score_pairs: tuple[tuple[int, float], ...] = ()
 
     def get_group_by(self, model=None):
         """Get the group by for the model."""
         if model is None:
             model = self.model
-        return self._ALTERNATE_GROUP_BY.get(model, "sort_name")  # type: ignore
+        return _ALTERNATE_GROUP_BY.get(model, "sort_name")  # type: ignore
 
     def _alias_sort_names(self, qs, model):
         """Annotate sort_name."""
@@ -133,7 +124,7 @@ class BrowserAnnotationsView(BrowserOrderByView, SharedAnnotationsMixin):
         # Get story_arc__pk
         group = self.kwargs["group"]
         pks = self.kwargs["pks"]
-        if group == self.STORY_ARC_GROUP and pks:
+        if group == STORY_ARC_GROUP and pks:
             story_arc_pks = pks
         else:
             story_arc_pks = self.params.get("filters", {}).get(  # type: ignore
@@ -150,7 +141,7 @@ class BrowserAnnotationsView(BrowserOrderByView, SharedAnnotationsMixin):
             )
             story_arc_number = self.order_agg_func("selected_story_arc_number__number")
         else:
-            story_arc_number = self._NONE_INTEGERFIELD
+            story_arc_number = _NONE_INTEGERFIELD
 
         return qs.alias(story_arc_number=story_arc_number)
 
@@ -168,19 +159,30 @@ class BrowserAnnotationsView(BrowserOrderByView, SharedAnnotationsMixin):
             qs = qs.annotate(page_count=page_count_sum)
         return qs
 
-    def _annotate_bookmark_updated_at(self, qs, model):
-        if self.is_opds_1_acquisition or self.order_key == "bookmark_updated_at":
-            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  # type: ignore
+    def get_bookmark_updated_at_aggregate(self, model, always_max=False):
+        """Get The aggregate function for relevant bookmark.updated_at."""
+        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  # type: ignore
+
+        updated_at_rel = f"{bm_rel}__updated_at"
+        agg_func = Max if always_max else self.order_agg_func
+        return agg_func(
+            updated_at_rel,
+            default=_NONE_DATETIMEFIELD,
+            filter=bm_filter,
+        )
 
-            updated_at_rel = f"{bm_rel}__updated_at"
-            bookmark_updated_at_aggregate = self.order_agg_func(
-                updated_at_rel,
-                default=self._NONE_DATETIMEFIELD,
-                filter=bm_filter,
+    def _annotate_bookmark_updated_at(self, qs, model):
+        if (
+            self.is_opds_1_acquisition
+            or self.order_key == "bookmark_updated_at"
+            or self.is_bookmark_filtered
+        ):
+            bookmark_updated_at_aggregate = self.get_bookmark_updated_at_aggregate(
+                model
             )
-            if self.TARGET == "opds1":
+            if self.TARGET == "opds1" or self.is_bookmark_filtered:
                 qs = qs.annotate(bookmark_updated_at=bookmark_updated_at_aggregate)
             else:
                 qs = qs.alias(bookmark_updated_at=bookmark_updated_at_aggregate)
@@ -191,11 +193,11 @@ class BrowserAnnotationsView(BrowserOrderByView, SharedAnnotationsMixin):
         # Determine order func
         if model == Folder and self.order_key == "filename":
             order_value = F("name")
-        elif model == Comic or self.order_key in self._ANNOTATED_ORDER_FIELDS:
+        elif model == Comic or self.order_key in _ANNOTATED_ORDER_FIELDS:
             # These are annotated in browser_annotaions
             order_value = F(self.order_key)
         else:
-            agg_func = self._ORDER_AGGREGATE_FUNCS[self.order_key]
+            agg_func = _ORDER_AGGREGATE_FUNCS[self.order_key]
             agg_func = self.order_agg_func if agg_func == Min else agg_func
             field = self.rel_prefix + self.order_key
             order_value = agg_func(field)
@@ -220,56 +222,29 @@ class BrowserAnnotationsView(BrowserOrderByView, SharedAnnotationsMixin):
             qs = self._annotate_order_value(qs, model)
         return qs
 
-    def _annotate_cover_pk(self, qs, model):
-        """Annotate the query set for the coverpath for the sort."""
-        # Select comics for the children by an outer ref for annotation
-        # Order the descendant comics by the sort argumentst
-        cover_style = self.params.get("cover_style")
-        if model == Comic:
-            default_cover_pk = F("pk")
-            default_cover_mtime = F("updated_at")
-        elif cover_style == "i":
-            default_cover_pk = None
-            default_cover_mtime = None
-        else:
-            # At this point it's only been filtered.
-            default_cover_pk = F(self.rel_prefix + "pk")
-            default_cover_mtime = F(self.rel_prefix + "updated_at")
-
-        if model in (Volume, Comic):
-            cover_custom = Value(False)
-            cover_pk = default_cover_pk
-            cover_mtime = default_cover_mtime
-        else:
-            cover_custom = F("custom_cover")
-            cover_pk = Case(
-                When(custom_cover__isnull=False, then=F("custom_cover__pk")),
-                default=default_cover_pk,
-            )
-            cover_mtime = Case(
-                When(custom_cover__isnull=False, then=F("custom_cover__updated_at")),
-                default=default_cover_mtime,
-            )
-
-        return qs.annotate(
-            cover_custom=cover_custom,
-            cover_pk=cover_pk,
-            cover_mtime=cover_mtime,
-            cover_pks=JsonGroupArray("cover_pk", distinct=True),
-        )
-
     def _annotate_group(self, qs, model):
         """Annotate Group."""
         value = "c" if model == Comic else self.model_group  # type: ignore
         return qs.annotate(group=Value(value, CharField(max_length=1)))
 
+    def _annotate_child_count(self, qs, model):
+        """Annotate Child Count."""
+        if self.TARGET == "opds2":
+            return qs
+
+        if model == Comic:
+            child_count_sum = _ONE_INTEGERFIELD
+        else:
+            child_count_sum = Count(self.rel_prefix + "pk", distinct=True)
+        return qs.annotate(child_count=child_count_sum)
+
     def _annotate_bookmarks(self, qs, model):
         """Hoist up bookmark annotations."""
         if model in self.bm_annotation_data:  # type: ignore
             bm_rel, bm_filter = self.bm_annotation_data[model]  # type: ignore
         else:
             bm_rel = self.get_bm_rel(model)
-            bm_filter = self._get_my_bookmark_filter(bm_rel)
+            bm_filter = self.get_my_bookmark_filter(bm_rel)
 
         page_rel = f"{bm_rel}__page"
         finished_rel = f"{bm_rel}__finished"
@@ -318,20 +293,16 @@ class BrowserAnnotationsView(BrowserOrderByView, SharedAnnotationsMixin):
                 output_field=BooleanField(),
             )
 
-        if (
-            self.is_opds_1_acquisition
-            or self.is_model_comic
-            and self.TARGET == "browser"
+        if self.is_opds_1_acquisition or (
+            self.is_model_comic and self.TARGET == "browser"
         ):
             qs = qs.annotate(page=bookmark_page)
-        else:
+        elif self.TARGET in frozenset({"metadata", "browser"}):
             qs = qs.alias(page=bookmark_page)
 
         if self.TARGET in frozenset({"metadata", "browser"}):
+            # Only used for progress and progress is only for metadata and browser anyway
             qs.annotate(finished=finished_aggregate)
-        else:
-            # Only used for progress
-            qs.alias(finished=finished_aggregate)
         return qs
 
     def _annotate_progress(self, qs):
@@ -346,88 +317,26 @@ class BrowserAnnotationsView(BrowserOrderByView, SharedAnnotationsMixin):
         progress = Case(When(page_count__gt=0, then=then), default=0.0)
         return qs.annotate(progress=progress)
 
+    def _annotate_mtime(self, qs, model):
+        """Annotations mtime."""
+        bm_rel = self.get_bm_rel(model)
+        bm_ua_rel = bm_rel + "__updated_at"
+        when_filter = {bm_ua_rel + "__gt": F("updated_at")}
+        mtime = Case(
+            When(**when_filter),
+            then=F(bm_ua_rel),
+            default=F("updated_at"),
+        )
+        return qs.annotate(mtime=mtime)
+
     def annotate_card_aggregates(self, qs, model):
         """Annotate aggregates that appear the browser card."""
-        qs = self._annotate_cover_pk(qs, model)
         if model == Comic:
             # comic adds order_value for cards late
             qs = self._annotate_order_value(qs, model)
         qs = self._annotate_group(qs, model)
         qs = self.annotate_group_names(qs, model)
+        qs = self._annotate_child_count(qs, model)
         qs = self._annotate_bookmarks(qs, model)
-        return self._annotate_progress(qs)
-
-    def annotate_for_metadata(self, qs, _model):
-        """Annotations only for metadata."""
-        return qs.annotate(mtime=Max("updated_at"))
-
-    def _get_cover_pk_query(self, cover_pks, group_ids):
-        """Get Cover Pk queryset for comic queryset."""
-        cover_style = self.params.get("cover_style")
-        if cover_style == "d":
-            # DYNAMIC COVERS
-            comic_qs = Comic.objects.filter(pk__in=cover_pks)
-            comic_qs = self.annotate_search_score(
-                comic_qs, Comic, self.cover_search_score_pairs
-            )
-            comic_qs = self.annotate_order_aggregates(comic_qs, Comic)
-            comic_qs = self.add_order_by(comic_qs, Comic)  # type: ignore
-        else:  # "f"
-            # FIRST COVERS
-            # The only filter at all is the model relation.
-            group_rel = _REL_MAP[self.model]  # type: ignore
-            comic_qs = Comic.objects.filter(**{f"{group_rel}__in": group_ids})
-
-            # Order generated irrespective of browser filters and order
-            if self.kwargs["group"] == "f":
-                order_key = "filename"
-            elif self.kwargs["group"] == "a":
-                order_key = "story_arc_number"
-            else:
-                order_key = "sort_name"
-
-            model_group = self.model_group  # type: ignore
-            show = MappingProxyType(self.params["show"])  # type: ignore
-            model_group = self.kwargs["group"]
-            comic_qs, comic_sort_names = self.alias_sort_names(
-                comic_qs, Comic, cover_pks, model_group, show
-            )
-            comic_qs = self.add_order_by(
-                comic_qs,
-                Comic,
-                order_key=order_key,
-                do_reverse=False,
-                comic_sort_names=comic_sort_names,
-            )
-        comic_qs = comic_qs.group_by("id")
-        return comic_qs.only("pk", "updated_at")
-
-    def re_cover_multi_groups(self, group_qs):
-        """Python hack to re-cover groups collapsed with group_by."""
-        # This would be better in the main query but OuterRef can't access annotations.
-        # So cover_pks aggregates all covers from multi groups like ids does.
-        if self.is_model_comic or self.params.get("cover_style") == "i":
-            return group_qs
-
-        recovered_group_list = []
-        for group in group_qs:
-            cover_pks = group.cover_pks
-            if len(cover_pks) == 1:
-                cover_pk = cover_pks[0]
-                cover_mtime = group.updated_at
-            else:
-                comic_qs = self._get_cover_pk_query(cover_pks, group.ids)
-                # print(comic_qs.explain())
-                # print(comic_qs.query)
-                cover = comic_qs[0]
-                cover_pk = cover.pk
-                if len(group.ids) == 1:
-                    cover_mtime = group.updated_at
-                else:
-                    cover_mtime = group.__class__.objects.filter(
-                        pk__in=group.ids
-                    ).aggregate(updated_at=Max("updated_at"))["updated_at"]
-            group.cover_mtime = cover_mtime
-            group.cover_pk = cover_pk
-            recovered_group_list.append(group)
-        return recovered_group_list
+        qs = self._annotate_progress(qs)
+        return self._annotate_mtime(qs, model)