codex 1.6.2__py3-none-any.whl → 1.6.3__py3-none-any.whl

codex/views/reader/arcs.py

@@ -4,7 +4,10 @@ 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.const import (
+    FOLDER_GROUP,
+    STORY_ARC_GROUP,
+)
 from codex.views.reader.books import ReaderBooksView
 
 
@@ -16,77 +19,85 @@ class ReaderArcsView(ReaderBooksView):
         super().__init__(*args, **kwargs)
         self.params: MappingProxyType = MappingProxyType({})
 
-    def _get_group_arc(self, book, attr):
-        """Create the volume arc."""
+    def _get_group_arc(self, book, attr, browser_arc_group, arcs, max_mtime):  # noqa: PLR0913
+        """Append the volume arc."""
+        if browser_arc_group == attr[0]:
+            return None, max_mtime
         group = getattr(book, attr, None)
         if not group:
-            return None
+            return None, max_mtime
 
         _, 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,
-        }
+        arcs.append(
+            {
+                "group": attr[0],
+                "pks": arc_pks,
+                "name": group.name,
+                "mtime": group.updated_at,
+            }
+        )
+        return max_none(max_mtime, group.updated_at)
 
-    def _get_folder_arc(self, book):
-        """Create the folder arc."""
+    def _get_folder_arc(self, book, browser_arc_group, arcs, max_mtime):
+        """Append the folder arc."""
         efv_flag = (
             AdminFlag.objects.only("on")
             .get(key=AdminFlag.FlagChoices.FOLDER_VIEW.value)
             .on
         )
-        if not efv_flag:
-            return None
+        if not efv_flag or browser_arc_group == FOLDER_GROUP:
+            return None, max_mtime
 
         folder = book.parent_folder
-        return {
-            "group": FOLDER_GROUP,
-            "pks": (folder.pk,),
-            "name": folder.name,
-            "mtime": folder.updated_at,
-        }
+        arcs.append(
+            {
+                "group": FOLDER_GROUP,
+                "pks": (folder.pk,),
+                "name": folder.name,
+                "mtime": folder.updated_at,
+            }
+        )
+        return max_none(max_mtime, folder.updated_at)
+
+    def _get_story_arcs(self, book, browser_arc, arcs, max_mtime):
+        """Append the story arcs."""
+        if browser_arc.get("group") == STORY_ARC_GROUP:
+            browser_arc_pks = frozenset(browser_arc.get("pks", ()))
+        else:
+            browser_arc_pks = frozenset()
 
-    def _get_story_arcs(self, book):
-        """Create story arcs."""
-        sas = []
-        for san in book.story_arc_numbers.all():
+        for san in book.story_arc_numbers.all().order_by("story_arc__name"):
             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"])
+            if not browser_arc_pks or sa.pk not in browser_arc_pks:
+                arc = {
+                    "group": "a",
+                    "pks": (sa.pk,),
+                    "name": sa.name,
+                    "mtime": sa.updated_at,
+                }
+                arcs.append(arc)
+                max_mtime = max_none(max_mtime, sa.updated_at)
+        return max_mtime
 
     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"])
+
+        if browser_arc := self.params.get("browser_arc", {}):
+            arcs.append(browser_arc)
+            max_mtime = max_none(max_mtime, browser_arc.get("mtime", max_mtime))
+
+        browser_arc_group = browser_arc.get("group", "")
+        max_mtime = self._get_group_arc(
+            book, "series", browser_arc_group, arcs, max_mtime
+        )
+        max_mtime = self._get_group_arc(
+            book, "volume", browser_arc_group, arcs, max_mtime
+        )
+        max_mtime = self._get_folder_arc(book, browser_arc_group, arcs, max_mtime)
+        max_mtime = self._get_story_arcs(book, browser_arc, arcs, max_mtime)
+
         return arcs, max_mtime

codex/views/reader/books.py

@@ -6,7 +6,14 @@ 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.browser.filters.field import ComicFieldFilterView
+from codex.views.const import (
+    FOLDER_GROUP,
+    GROUP_MODEL_MAP,
+    GROUP_RELATION,
+    NONE_INTEGERFIELD,
+    STORY_ARC_GROUP,
+)
 from codex.views.mixins import SharedAnnotationsMixin
 from codex.views.reader.init import ReaderInitView
 
@@ -57,45 +64,30 @@ class ReaderBooksView(BookmarkBaseView, ReaderInitView, SharedAnnotationsMixin):
 
     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_group = arc.get("group", "")
+        if not GROUP_MODEL_MAP.get(arc_group):
+            arc_group = "s"
+
+        rel = GROUP_RELATION[arc_group]
+        fields = _COMIC_FIELDS
+        arc_pk_rel = rel + "__pk"
+        arc_index = NONE_INTEGERFIELD
+        ordering = ()
+        arc_pk_select_related = (rel,)
+        select_related = ()
+        prefetch_related = ()
+
+        if arc_group == STORY_ARC_GROUP:
+            prefetch_related = (*prefetch_related, rel)
             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
+            select_related = (rel,)
+            fields = (*_COMIC_FIELDS, rel)
             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
@@ -103,12 +95,20 @@ class ReaderBooksView(BookmarkBaseView, ReaderInitView, SharedAnnotationsMixin):
         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)
+        if browser_filters := arc.get("filters"):
+            # no search at this time.
+            field_filters = ComicFieldFilterView.get_all_comic_field_filters(
+                "", browser_filters
+            )
+            qs = qs.filter(field_filters)
+
+        if select_related:
+            qs = qs.select_related(*select_related)
+        if prefetch_related:
+            qs = qs.prefetch_related(*prefetch_related)
         qs = (
-            Comic.objects.filter(group_acl_filter)
-            .filter(**nav_filter)
-            .select_related(*select_related)
-            .prefetch_related(*prefetch_related)
-            .only(*fields)
+            qs.only(*fields)
             .annotate(
                 issue_count=F("volume__issue_count"),
             )

codex/views/reader/init.py

@@ -13,8 +13,8 @@ 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"})
+VALID_ARC_GROUPS = "pisvfa"
+_JSON_KEYS = frozenset({"arc", "breadcrumbs", "browser_arc", "show"})
 _BROWSER_SESSION_DEFAULTS = SessionView.SESSION_DEFAULTS[
     SessionView.BROWSER_SESSION_KEY
 ]
@@ -89,12 +89,14 @@ class ReaderInitView(SessionView):
         # Can't be in the serializer
         arc = params.get("arc", {})
 
-        if arc.get("group") not in VALID_ARC_GROUPS:
+        arc_group = arc.get("group", "")
+        arc_pks = arc.get("pks", ())
+        if arc_group not in VALID_ARC_GROUPS or not arc_pks:
             top_group = params["top_group"]
-            if top_group in (FOLDER_GROUP, STORY_ARC_GROUP):
+            if top_group in FOLDER_GROUP + STORY_ARC_GROUP:
                 search_groups = (top_group,)
             else:
-                search_groups = ("v", "s")
+                search_groups = "vsip"
 
             group, pks = self.get_group_pks_from_breadcrumbs(search_groups)
             if not group:

codex/views/reader/reader.py

@@ -12,7 +12,6 @@ from codex.logger.logging import get_logger
 from codex.serializers.reader import ReaderComicsSerializer, ReaderViewInputSerializer
 from codex.serializers.redirect import ReaderRedirectSerializer
 from codex.views.reader.arcs import ReaderArcsView
-from codex.views.util import pop_name
 
 LOG = get_logger(__name__)
 
@@ -90,7 +89,6 @@ class ReaderView(ReaderArcsView):
         arc["count"] = current.arc_count  # type: ignore
 
         close_route = self.get_last_route()
-        close_route = pop_name(close_route)
 
         return {
             "books": books,

{codex-1.6.2.dist-info → codex-1.6.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: codex
-Version: 1.6.2
+Version: 1.6.3
 Summary: A comic archive web server.
 Home-page: https://github.com/ajslater/codex
 License: GPL-3.0-only