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

codex/views/opds/v2/publications.py

@@ -1,69 +1,47 @@
 """Publication Methods for OPDS v2.0 feed."""
 
+from datetime import datetime
+from math import floor
 from types import MappingProxyType
 from urllib.parse import quote_plus
 
-from django.contrib.staticfiles.storage import staticfiles_storage
-
 from codex.librarian.covers.create import CoverCreateMixin
 from codex.models import Comic
 from codex.views.opds.const import AUTHOR_ROLES, MimeType, Rel
 from codex.views.opds.util import get_contributors, get_m2m_objects
-from codex.views.opds.v2.links import HrefData, LinkData, LinksMixin
-
-
-class PublicationMixin(LinksMixin):
+from codex.views.opds.v2.top_links import HrefData, LinkData, OPDS2TopLinksView
+
+_MD_CONTRIBUTOR_MAP = MappingProxyType(
+    {
+        "author": AUTHOR_ROLES,
+        # "translator": {},
+        "editor": {"Editor"},
+        "artist": {"CoverArtist"},
+        # "illustrator": {},
+        "letterer": {"Letterer"},
+        "penciller": {"Penciller"},
+        "colorist": {"Colorist"},
+        "inker": {"Inker"},
+    }
+)
+_CONTRIBUTOR_ROLES = frozenset({x for s in _MD_CONTRIBUTOR_MAP.values() for x in s})
+
+
+class OPDS2PublicationView(OPDS2TopLinksView):
     """Publication Methods for OPDS 2.0 feed."""
 
-    _MD_CONTRIBUTOR_MAP = MappingProxyType(
-        {
-            "author": AUTHOR_ROLES,
-            # "translator": {},
-            "editor": {"Editor"},
-            "artist": {"CoverArtist"},
-            # "illustrator": {},
-            "letterer": {"Letterer"},
-            "penciller": {"Penciller"},
-            "colorist": {"Colorist"},
-            "inker": {"Inker"},
-        }
-    )
-    _CONTRIBUTOR_ROLES = frozenset({x for s in _MD_CONTRIBUTOR_MAP.values() for x in s})
     is_opds_metadata = False
 
-    def _get_big_image_link(self, obj, cover_pk):
-        if cover_pk:
-            mime_type = MimeType.JPEG
-            url_name = "opds:bin:page"
-            href = None
-            min_page = 0
-            max_page = obj.max_page or 1
-        else:
-            mime_type = MimeType.WEBP
-            href = staticfiles_storage.url("img/missing_cover.webp")
-            url_name = None
-            min_page = None
-            max_page = None
-
-        kwargs = {"pk": obj.pk, "page": 0}
-        href_data = HrefData(
-            kwargs,
-            absolute_query_params=True,
-            url_name=url_name,
-            min_page=min_page,
-            max_page=max_page,
-        )
-        link_data = LinkData(Rel.IMAGE, href_data, href=href, mime_type=mime_type)
-        return self.link(link_data)
-
     def _images(self, obj):
         # Images
-        cover_pk = obj.cover_pk
-
-        kwargs = {"pk": cover_pk}
-        href_data = HrefData(
-            kwargs, url_name="opds:bin:cover", absolute_query_params=True
-        )
+        kwargs = {"group": obj.group, "pks": obj.ids}
+        ts = floor(datetime.timestamp(obj.updated_at))
+        query_params = {
+            "customCovers": True,
+            "dynamicCovers": False,
+            "ts": ts,
+        }
+        href_data = HrefData(kwargs, query_params, True, "opds:bin:cover")
         link_data = LinkData(
             Rel.THUMBNAIL,
             href_data,
@@ -74,7 +52,9 @@ class PublicationMixin(LinksMixin):
 
         cover_link = self.link(link_data)
 
-        image_link = self._get_big_image_link(obj, cover_pk)
+        link_data.rel = Rel.IMAGE
+
+        image_link = self.link(link_data)
 
         return [
             cover_link,
@@ -82,9 +62,9 @@ class PublicationMixin(LinksMixin):
         ]
 
     @staticmethod
-    def _add_contributors(md, pk, key, roles):
+    def _add_contributors(md, pks, key, roles):
         """Add contributors to metadata."""
-        if contributors := get_contributors(pk, roles):
+        if contributors := get_contributors(pks, roles):
             md[key] = contributors
 
     def _publication_optional_metadata(self, md, obj):
@@ -106,12 +86,12 @@ class PublicationMixin(LinksMixin):
 
     def _publication_extended_metadata(self, md, obj):
         """Publication m2m metadata only on the metadata alternate link."""
-        for key, roles in self._MD_CONTRIBUTOR_MAP.items():
-            self._add_contributors(md, obj.pk, key, roles)
-        if contributors := get_contributors(obj.pk, self._CONTRIBUTOR_ROLES, True):
+        for key, roles in _MD_CONTRIBUTOR_MAP.items():
+            self._add_contributors(md, obj.ids, key, roles)
+        if contributors := get_contributors(obj.ids, _CONTRIBUTOR_ROLES, True):
             md["contributor"] = contributors
 
-        if m2m_objs := get_m2m_objects(obj.pk):
+        if m2m_objs := get_m2m_objects(obj.ids):
             # XXX Subjects can also have links
             # https://readium.org/webpub-manifest/schema/subject-object.schema.json
             subjects = []
@@ -120,12 +100,12 @@ class PublicationMixin(LinksMixin):
                     subjects.append(subj.name)
             md["subject"] = subjects
 
-    def _publication_metadata(self, obj, issue_number_max):
+    def _publication_metadata(self, obj, zero_pad):
         title = Comic.get_title(
             obj,
             volume=False,
             name=False,
-            issue_number_max=issue_number_max,
+            zero_pad=zero_pad,
             filename_fallback=self.title_filename_fallback,
         )
         md = {
@@ -139,15 +119,14 @@ class PublicationMixin(LinksMixin):
             self._publication_extended_metadata(md, obj)
         return md
 
-    def _publication(self, obj, issue_number_max):
+    def _publication(self, obj, zero_pad):
         pub = {}
-        pub["metadata"] = self._publication_metadata(obj, issue_number_max)
+        pub["metadata"] = self._publication_metadata(obj, zero_pad)
 
-        fn = Comic.get_filename(obj)
-        fn = quote_plus(fn)
+        fn = quote_plus(obj.get_filename())
 
         download_mime_type = MimeType.FILE_TYPE_MAP.get(obj.file_type, MimeType.OCTET)
-        self_kwargs = {"group": "c", "pk": obj.pk, "page": 1}
+        self_kwargs = {"pk": obj.pk, "page": 1}
 
         # This would be for comic streaming which is not supported by OPDS 2 yet?
         # self_href_data = HrefData(self_kwargs, absolute_query_params=True)
@@ -155,7 +134,10 @@ class PublicationMixin(LinksMixin):
 
         alt_kwargs = self_kwargs
         alt_href_data = HrefData(
-            alt_kwargs, {"opdsMetadata": 1}, absolute_query_params=True
+            alt_kwargs,
+            {"opdsMetadata": 1},
+            absolute_query_params=True,
+            url_name="opds:v2:acq",
         )
         alt_link_data = LinkData(
             Rel.ALTERNATE, alt_href_data, mime_type=MimeType.OPDS_PUB
@@ -186,13 +168,13 @@ class PublicationMixin(LinksMixin):
 
         return pub
 
-    def get_publications(self, book_qs, issue_number_max, title):
+    def get_publications(self, book_qs, zero_pad, title):
         """Get publications section."""
         groups = []
         publications = []
         self.title_filename_fallback = bool(self.admin_flags.get("folder_view"))
         for obj in book_qs:
-            pub = self._publication(obj, issue_number_max)
+            pub = self._publication(obj, zero_pad)
             publications.append(pub)
 
         if publications:

codex/views/opds/v2/top_links.py

@@ -1,10 +1,10 @@
 """OPDS v2.0 top links section methods."""
 
 from codex.views.opds.const import MimeType, Rel
-from codex.views.opds.v2.links import HrefData, LinkData, LinksMixin
+from codex.views.opds.v2.links import HrefData, LinkData, OPDS2LinksView
 
 
-class TopLinksMixin(LinksMixin):
+class OPDS2TopLinksView(OPDS2LinksView):
     """OPDS 2.0 top links section methods."""
 
     def _link_auth(self):
@@ -21,7 +21,7 @@ class TopLinksMixin(LinksMixin):
         return self.link(link_data)
 
     def _link_search(self):
-        kwargs = {"group": "s", "pk": 0, "page": 1}
+        kwargs = {"group": "s", "pks": (0,), "page": 1}
         href_data = HrefData(kwargs, absolute_query_params=True, max_page=1)
         link_data = LinkData(Rel.SEARCH, href_data, template="{?query}")
         return self.link(link_data)
@@ -55,7 +55,7 @@ class TopLinksMixin(LinksMixin):
 
     def _top_route(self):
         group = "f" if self.kwargs.get("group") == "f" else "r"
-        return {"group": group, "pk": 0, "page": 1}
+        return {"group": group, "pks": (0,), "page": 1}
 
     def _link_page(self, rel, page):
         """Links to a page of results."""

codex/views/public.py

@@ -0,0 +1,36 @@
+"""Public non-authenticated views."""
+
+from rest_framework.generics import GenericAPIView
+from rest_framework.mixins import RetrieveModelMixin
+
+from codex.logger.logging import get_logger
+from codex.models import AdminFlag
+from codex.serializers.auth import AuthAdminFlagsSerializer
+from codex.serializers.choices import CHOICES
+
+LOG = get_logger(__name__)
+_ADMIN_FLAG_KEYS = frozenset(
+    {
+        AdminFlag.FlagChoices.NON_USERS.value,
+        AdminFlag.FlagChoices.REGISTRATION.value,
+    }
+)
+
+
+class AdminFlagsView(GenericAPIView, RetrieveModelMixin):
+    """Get admin flags relevant to auth."""
+
+    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)

codex/views/reader/arcs.py

@@ -0,0 +1,92 @@
+"""Reader get Arcs methods."""
+
+from types import MappingProxyType
+
+from codex.models import AdminFlag
+from codex.util import max_none
+from codex.views.const import FOLDER_GROUP, STORY_ARC_GROUP
+from codex.views.reader.books import ReaderBooksView
+
+
+class ReaderArcsView(ReaderBooksView):
+    """Reader get Arcs methods."""
+
+    def __init__(self, *args, **kwargs):
+        """Initialize instance vars."""
+        super().__init__(*args, **kwargs)
+        self.params: MappingProxyType = MappingProxyType({})
+
+    def _get_group_arc(self, book, attr):
+        """Create the volume arc."""
+        group = getattr(book, attr, None)
+        if not group:
+            return None
+
+        _, arc_pks = self.get_group_pks_from_breadcrumbs([group])
+        if group.pk not in arc_pks:
+            arc_pks = (group.pk,)
+        return {
+            "group": attr[0],
+            "pks": arc_pks,
+            "name": group.name,
+            "mtime": group.updated_at,
+        }
+
+    def _get_folder_arc(self, book):
+        """Create the folder arc."""
+        efv_flag = (
+            AdminFlag.objects.only("on")
+            .get(key=AdminFlag.FlagChoices.FOLDER_VIEW.value)
+            .on
+        )
+        if not efv_flag:
+            return None
+
+        folder = book.parent_folder
+        return {
+            "group": FOLDER_GROUP,
+            "pks": (folder.pk,),
+            "name": folder.name,
+            "mtime": folder.updated_at,
+        }
+
+    def _get_story_arcs(self, book):
+        """Create story arcs."""
+        sas = []
+        for san in book.story_arc_numbers.all():
+            sa = san.story_arc
+            arc = {
+                "group": "a",
+                "pks": (sa.pk,),
+                "name": sa.name,
+                "mtime": sa.updated_at,
+            }
+            sas.append(arc)
+        return sorted(sas, key=lambda x: x["name"])
+
+    def get_arcs(self, book):
+        """Get all series/folder/story arcs."""
+        # create top arcs
+        arcs = []
+        top_group = self.params.get("top_group")
+        arc = None
+        if series_arc := self._get_group_arc(book, "series"):
+            arcs.append(series_arc)
+            arc = series_arc
+        if volume_arc := self._get_group_arc(book, "volume"):
+            arcs.append(volume_arc)
+            if not arc:
+                arc = volume_arc
+        if folder_arc := self._get_folder_arc(book):
+            arcs.append(folder_arc)
+            if top_group == FOLDER_GROUP:
+                arc = folder_arc
+        if story_arcs := self._get_story_arcs(book):
+            arcs = [*arcs, *story_arcs]
+            if top_group == STORY_ARC_GROUP:
+                arc = story_arcs[0]
+
+        max_mtime = None
+        for arc in arcs:
+            max_mtime = max_none(max_mtime, arc["mtime"])
+        return arcs, max_mtime

codex/views/reader/books.py

@@ -0,0 +1,181 @@
+"""Get Books methods."""
+
+from typing import TYPE_CHECKING
+
+from django.db.models import F
+
+from codex.models import Bookmark, Comic
+from codex.views.bookmark import BookmarkBaseView
+from codex.views.const import FOLDER_GROUP, NONE_INTEGERFIELD
+from codex.views.mixins import SharedAnnotationsMixin
+from codex.views.reader.init import ReaderInitView
+
+if TYPE_CHECKING:
+    from collections.abc import Mapping
+
+_SETTINGS_ATTRS = ("fit_to", "two_pages", "reading_direction")
+_COMIC_FIELDS = (
+    "file_type",
+    "issue_number",
+    "issue_suffix",
+    "page_count",
+    "series",
+    "volume",
+    "reading_direction",
+    "updated_at",
+)
+
+
+class ReaderBooksView(BookmarkBaseView, ReaderInitView, SharedAnnotationsMixin):
+    """Get Books methods."""
+
+    def _get_reader_arc_pks(  # noqa: PLR0913
+        self, arc, arc_pk_select_related, prefetch_related, arc_pk_rel, arc_group
+    ):
+        """Get the nav filter."""
+        if arc_pks := arc.get("pks", ()):
+            return arc_pks
+
+        comic_pk = self.kwargs["pk"]
+        try:
+            arc_pk_qs = Comic.objects.filter(pk=comic_pk)
+            arc_pk_qs = arc_pk_qs.select_related(*arc_pk_select_related)
+            arc_pk_qs = arc_pk_qs.prefetch_related(*prefetch_related)
+            arc_pk_qs = arc_pk_qs.values_list(arc_pk_rel, flat=True)
+            arc_pk = arc_pk_qs.first()
+        except IndexError:
+            arc_pk = 0
+
+        _, multi_arc_pks = self.get_group_pks_from_breadcrumbs([arc_group])
+        if not arc_pk or arc_pk in multi_arc_pks:
+            arc_pks = multi_arc_pks
+
+        if not arc_pks:
+            arc_pks = (arc_pk,)
+
+        return arc_pks
+
+    def _get_comics_list(self):
+        """Get the reader naviation group filter."""
+        select_related = ("series", "volume")
+        prefetch_related = ()
+
+        arc: Mapping = self.params.get("arc", {})  # type: ignore
+
+        arc_group = arc.get("group", "s")
+        if arc_group == "a":
+            # for story arcs
+            rel = "story_arc_numbers__story_arc"
+            fields = _COMIC_FIELDS
+            arc_pk_rel = "story_arc_numbers__story_arc__pk"
+            prefetch_related = (*prefetch_related, "story_arc_numbers__story_arc")
+            arc_index = F("story_arc_numbers__number")
+            ordering = ("arc_index", "date", "pk")
+            arc_pk_select_related = ()
+        elif arc_group == FOLDER_GROUP:
+            # folder mode
+            rel = "parent_folder"
+            fields = (*_COMIC_FIELDS, "parent_folder")
+            arc_pk_rel = "parent_folder__pk"
+            arc_index = NONE_INTEGERFIELD
+            ordering = ("path", "pk")
+            arc_pk_select_related = ("parent_folder",)
+        elif arc_group == "v":
+            # volume
+            rel = "volume"
+            fields = _COMIC_FIELDS
+            arc_pk_rel = "volume__pk"
+            arc_index = NONE_INTEGERFIELD
+            ordering = ()
+            arc_pk_select_related = ("volume",)
+        else:
+            # series
+            rel = "series"
+            fields = _COMIC_FIELDS
+            arc_pk_rel = "series__pk"
+            arc_index = NONE_INTEGERFIELD
+            ordering = ()
+            arc_pk_select_related = ("series",)
+
+        arc_pks = self._get_reader_arc_pks(
+            arc, arc_pk_select_related, prefetch_related, arc_pk_rel, arc_group
+        )
+        nav_filter = {f"{rel}__in": arc_pks}
+        group_acl_filter = self.get_group_acl_filter(Comic)
+
+        qs = (
+            Comic.objects.filter(group_acl_filter)
+            .filter(**nav_filter)
+            .select_related(*select_related)
+            .prefetch_related(*prefetch_related)
+            .only(*fields)
+            .annotate(
+                issue_count=F("volume__issue_count"),
+            )
+            .annotate(
+                arc_pk=F(arc_pk_rel),
+                arc_index=arc_index,
+            )
+            .annotate(mtime=F("updated_at"))
+        )
+        qs = self.annotate_group_names(qs, Comic)
+        if arc_group in ("v", "s"):
+            show = self.params["show"]
+            model_group = "i" if arc_group == "s" else "s"
+            qs, comic_sort_names = self.alias_sort_names(
+                qs, Comic, pks=arc_pks, model_group=model_group, show=show
+            )
+            ordering = (
+                *comic_sort_names,
+                "issue_number",
+                "issue_suffix",
+                "sort_name",
+            )
+        qs = qs.order_by(*ordering)
+        return qs, arc_group
+
+    def _append_with_settings(self, book, bookmark_filter):
+        """Append bookmark to book list."""
+        book.settings = (
+            Bookmark.objects.filter(**bookmark_filter, comic=book)
+            .only(*_SETTINGS_ATTRS)
+            .first()
+        )
+        return book
+
+    def get_book_collection(self):
+        """Get the -1, +1 window around the current issue.
+
+        Uses iteration in python. There are some complicated ways of
+        doing this with __gt[0] & __lt[0] in the db, but I think they
+        might be even more expensive.
+
+        Yields 1 to 3 books
+        """
+        comics, arc_group = self._get_comics_list()
+        bookmark_filter = self.get_bookmark_search_kwargs()
+        books = {}
+        prev_book = None
+        pk = self.kwargs.get("pk")
+        for index, book in enumerate(comics):
+            if books:
+                # after match set next comic and break
+                books["next"] = self._append_with_settings(book, bookmark_filter)
+                break
+            if book.pk == pk:
+                # first match. set previous and current comic
+                if prev_book:
+                    books["prev"] = self._append_with_settings(
+                        prev_book, bookmark_filter
+                    )
+                # create extra current book attrs:
+                if book.arc_index is None:
+                    book.arc_index = index + 1
+                book.filename = book.get_filename()
+                book.arc_group = arc_group
+                book.arc_count = comics.count()
+                books["current"] = self._append_with_settings(book, bookmark_filter)
+            else:
+                # Haven't matched yet, so set the previous comic
+                prev_book = book
+        return books

codex/views/reader/init.py

@@ -0,0 +1,125 @@
+"""Views for reading comic books."""
+
+from copy import deepcopy
+from types import MappingProxyType
+
+from codex.logger.logging import get_logger
+from codex.models import Comic
+from codex.serializers.reader import (
+    ReaderViewInputSerializer,
+)
+from codex.views.const import FOLDER_GROUP, GROUP_RELATION, STORY_ARC_GROUP
+from codex.views.session import SessionView
+from codex.views.util import reparse_json_query_params
+
+LOG = get_logger(__name__)
+VALID_ARC_GROUPS = frozenset({"s", "v", "f", "a"})
+_JSON_KEYS = frozenset({"arc", "breadcrumbs", "show"})
+_BROWSER_SESSION_DEFAULTS = SessionView.SESSION_DEFAULTS[
+    SessionView.BROWSER_SESSION_KEY
+]
+_DEFAULT_PARAMS = {
+    "breadcrumbs": _BROWSER_SESSION_DEFAULTS["breadcrumbs"],
+    "show": _BROWSER_SESSION_DEFAULTS["show"],
+    "top_group": _BROWSER_SESSION_DEFAULTS["top_group"],
+}
+
+
+class ReaderInitView(SessionView):
+    """Reader initialization."""
+
+    input_serializer_class = ReaderViewInputSerializer
+
+    def __init__(self, *args, **kwargs):
+        """Initialize instance vars."""
+        super().__init__(*args, **kwargs)
+        self.group_pks: dict[str, tuple[int, ...]] = {}
+
+    def _set_group_pks_from_breadcrumbs(self, groups, breadcrumbs):
+        """Set Multi-Group pks from breadcrumbs to the cache."""
+        index = len(breadcrumbs) - 1
+        min_index = max(index - 1, 0) if FOLDER_GROUP in groups else 0
+        while index > min_index:
+            crumb = breadcrumbs[index]
+            crumb_group = crumb.get("group")
+            if crumb_group in groups:
+                pks = crumb.get("pks", ())
+                self.group_pks[crumb_group] = pks
+                break
+            index -= 1
+        else:
+            crumb_group = ""
+            pks = ()
+            for group in groups:
+                self.group_pks[group] = pks
+        return crumb_group, pks
+
+    def get_group_pks_from_breadcrumbs(self, groups):
+        """Get Multi-Group pks from the breadcrumbs."""
+        # Return cached values
+        for group in groups:
+            if pks := self.group_pks.get(group):
+                return group, pks
+
+        # Validate input
+        breadcrumbs: tuple = self.params.get("breadcrumbs")  # type: ignore
+        if not breadcrumbs:
+            return "", ()
+
+        return self._set_group_pks_from_breadcrumbs(groups, breadcrumbs)
+
+    def _ensure_arc_contains_comic(self, params):
+        """Arc sanity check."""
+        arc = params.get("arc")
+        if not arc:
+            return
+        pk = self.kwargs["pk"]
+        arc_group = arc.get("group")
+        arc_pks = arc.get("pks")
+        valid = False
+        if rel := GROUP_RELATION.get(arc_group):
+            arc_filter = {rel: arc_pks}
+            valid = Comic.objects.filter(pk=pk, **arc_filter).exists()
+        if not valid:
+            LOG.warning(f"Invalid arc {arc} submitted to reader for comic {pk}.")
+            params.pop("arc", None)
+
+    def _ensure_arc(self, params):
+        """arc.group validation."""
+        # Can't be in the serializer
+        arc = params.get("arc", {})
+
+        if arc.get("group") not in VALID_ARC_GROUPS:
+            top_group = params["top_group"]
+            if top_group in (FOLDER_GROUP, STORY_ARC_GROUP):
+                search_groups = (top_group,)
+            else:
+                search_groups = ("v", "s")
+
+            group, pks = self.get_group_pks_from_breadcrumbs(search_groups)
+            if not group:
+                group = "s"
+
+            arc["group"] = group
+            if pks:
+                arc["pks"] = pks
+
+        params["arc"] = arc
+
+    def _parse_params(self):
+        try:
+            data = self.request.GET
+            data = reparse_json_query_params(self.request.GET, _JSON_KEYS)
+            serializer = self.input_serializer_class(data=data)
+            serializer.is_valid(raise_exception=True)
+
+            params = deepcopy(_DEFAULT_PARAMS)
+            if serializer.validated_data:
+                params.update(serializer.validated_data)  # type: ignore
+            self._ensure_arc_contains_comic(params)
+            self._ensure_arc(params)
+
+            self.params = MappingProxyType(params)
+        except Exception:
+            LOG.exception("validate")
+            raise