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

codex/views/bookmark.py

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

codex/views/browser/annotations.py

@@ -0,0 +1,293 @@
+"""Base view for metadata annotations."""
+
+from os import sep
+from types import MappingProxyType
+
+from django.db.models import (
+    Avg,
+    BooleanField,
+    Case,
+    F,
+    FilteredRelation,
+    Min,
+    Q,
+    Sum,
+    Value,
+    When,
+)
+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,
+    StoryArc,
+    Volume,
+)
+from codex.models.functions import JsonGroupArray
+from codex.views.browser.order_by import (
+    BrowserOrderByView,
+)
+from codex.views.const import (
+    NONE_DATETIMEFIELD,
+    NONE_INTEGERFIELD,
+    STORY_ARC_GROUP,
+)
+from codex.views.mixins import SharedAnnotationsMixin
+
+_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", Folder: "name"}
+)
+
+LOG = get_logger(__name__)
+
+
+class BrowserAnnotationsView(BrowserOrderByView, SharedAnnotationsMixin):
+    """Base class for views that need special metadata annotations."""
+
+    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]] = {}
+
+    def get_group_by(self, model=None):
+        """Get the group by for the model."""
+        if model is None:
+            model = self.model
+        return _ALTERNATE_GROUP_BY.get(model, "sort_name")  # type: ignore
+
+    def _alias_sort_names(self, qs, model):
+        """Annotate sort_name."""
+        if self.order_key != "sort_name" and not (
+            model == StoryArc and self.order_key == "story_arc_number"
+        ):
+            return qs
+        pks = self.kwargs.get("pks")
+        model_group = self.model_group  # type: ignore
+        show = MappingProxyType(self.params["show"])  # type: ignore
+        qs, self.comic_sort_names = self.alias_sort_names(
+            qs, model, pks, model_group, show
+        )
+        return qs
+
+    def _alias_filename(self, qs, model):
+        """Calculate filename from path in the db."""
+        if self.order_key != "filename":
+            return qs
+        if model == Folder:
+            filename = F("name")
+        else:
+            prefix = "" if model == Comic else self.rel_prefix
+            path_rel = prefix + "path"
+            filename = self.order_agg_func(
+                Right(
+                    path_rel,
+                    StrIndex(Reverse(F(path_rel)), Value(sep)) - 1,  # type: ignore
+                    output_field=CharField(),
+                )
+            )
+        return qs.alias(filename=filename)
+
+    def _alias_story_arc_number(self, qs):
+        if self.order_key != "story_arc_number":
+            return qs
+
+        # Get story_arc__pk
+        group = self.kwargs["group"]
+        pks = self.kwargs["pks"]
+        if group == STORY_ARC_GROUP and pks:
+            story_arc_pks = pks
+        else:
+            story_arc_pks = self.params.get("filters", {}).get(  # type: ignore
+                "story_arcs", ()
+            )
+
+        # If we have one annotate it.
+        if story_arc_pks:
+            san_rel = self.rel_prefix + "story_arc_numbers"
+            rel = f"{san_rel}"
+            condition = Q(**{f"{san_rel}__story_arc__in": story_arc_pks})
+            qs = qs.alias(
+                selected_story_arc_number=FilteredRelation(rel, condition=condition),
+            )
+            story_arc_number = self.order_agg_func("selected_story_arc_number__number")
+        else:
+            story_arc_number = NONE_INTEGERFIELD
+
+        return qs.alias(story_arc_number=story_arc_number)
+
+    def _annotate_page_count(self, qs, model):
+        """Hoist up total page_count of children."""
+        # Used for sorting and progress
+        if model == Comic:
+            return qs
+
+        rel = self.rel_prefix + "page_count"
+        page_count_sum = Sum(rel, distinct=True)
+        if self.TARGET == "browser":
+            qs = qs.alias(page_count=page_count_sum)
+        else:
+            qs = qs.annotate(page_count=page_count_sum)
+        return qs
+
+    def _annotate_bookmark_updated_at(self, qs, model):
+        if not self.is_opds_1_acquisition and self.order_key != "bookmark_updated_at":
+            return qs
+        bm_rel, bm_filter = self.get_bookmark_rel_and_filter(model)
+        bm_updated_at_rel = f"{bm_rel}__updated_at"
+        bmua_agg = self.order_agg_func(
+            bm_updated_at_rel, default=NONE_DATETIMEFIELD, filter=bm_filter
+        )
+        return qs.annotate(bookmark_updated_at=bmua_agg)
+
+    def _annotate_order_value(self, qs, model):
+        """Annotate a main key for sorting and browser card display."""
+        # Determine order func
+        if self.TARGET == "metadata":
+            return qs
+        if model == Folder and self.order_key == "filename":
+            order_value = F("name")
+        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 = _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)
+
+        if self.TARGET == "browser":
+            qs = qs.annotate(order_value=order_value)
+        else:
+            qs = qs.alias(order_value=order_value)
+        return qs
+
+    def annotate_order_aggregates(self, qs, model):
+        """Annotate common aggregates between browser and metadata."""
+        qs = qs.annotate(ids=JsonGroupArray("id", distinct=True))
+        qs = self._alias_sort_names(qs, model)
+        qs = self._alias_filename(qs, model)
+        qs = self._alias_story_arc_number(qs)
+        qs = self._annotate_page_count(qs, model)
+        qs = self._annotate_bookmark_updated_at(qs, model)
+        if model != Comic:
+            # comic orders on indexed fields when it can
+            qs = self._annotate_order_value(qs, model)
+        return qs
+
+    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_bookmarks(self, qs, model):
+        """Hoist up bookmark annotations."""
+        bm_rel, bm_filter = self.get_bookmark_rel_and_filter(model)
+
+        page_rel = f"{bm_rel}__page"
+        finished_rel = f"{bm_rel}__finished"
+
+        if model == Comic:
+            # Hoist up the bookmark and finished states
+            bookmark_page = Sum(
+                page_rel,
+                default=0,
+                filter=bm_filter,
+                output_field=PositiveSmallIntegerField(),
+            )
+            finished_aggregate = Sum(
+                finished_rel,
+                default=False,
+                filter=bm_filter,
+                output_field=BooleanField(),
+            )
+        else:
+            # Aggregate bookmark and finished states
+            bookmark_page = Sum(
+                Case(
+                    When(**{bm_rel: None}, then=0),
+                    When(**{finished_rel: True}, then=f"{self.rel_prefix}page_count"),
+                    default=page_rel,
+                    output_field=PositiveSmallIntegerField(),
+                ),
+                default=0,
+                filter=bm_filter,
+                output_field=PositiveSmallIntegerField(),
+                distinct=True,
+            )
+
+            finished_count = Sum(
+                finished_rel,
+                default=0,
+                filter=bm_filter,
+                output_field=PositiveSmallIntegerField(),
+                distinct=True,
+            )
+            qs = qs.annotate(finished_count=finished_count)
+            finished_aggregate = Case(
+                When(finished_count=F("child_count"), then=True),
+                When(finished_count=0, then=False),
+                default=None,
+                output_field=BooleanField(),
+            )
+
+        if self.is_opds_1_acquisition or (
+            self.is_model_comic and self.TARGET == "browser"
+        ):
+            qs = qs.annotate(page=bookmark_page)
+        elif self.TARGET in frozenset({"metadata", "browser"}):
+            qs = qs.alias(page=bookmark_page)
+
+        if self.TARGET in frozenset({"metadata", "browser"}):
+            qs = qs.annotate(finished=finished_aggregate)
+        return qs
+
+    def _annotate_progress(self, qs):
+        """Compute progress for each member of a qs."""
+        if self.TARGET not in frozenset({"metadata", "browser"}):
+            return qs
+        # Requires bookmark and annotation hoisted from bookmarks.
+        # Requires page_count native to comic or aggregated
+        # Least guard is for rare instances when bookmarks are set to
+        # invalid high values
+        then = Least(F("page") * 100.0 / F("page_count"), Value(100.0))
+        progress = Case(When(page_count__gt=0, then=then), default=0.0)
+        return qs.annotate(progress=progress)
+
+    def annotate_card_aggregates(self, qs, model):
+        """Annotate aggregates that appear the browser card."""
+        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_bookmarks(qs, model)
+        qs = self._annotate_progress(qs)
+        return qs.annotate(updated_ats=JsonGroupArray("updated_at", distinct=True))