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

codex/views/browser/filters/group.py

@@ -12,11 +12,14 @@ class GroupFilterView(SessionView):
 
     SESSION_KEY = SessionView.BROWSER_SESSION_KEY
 
-    def get_group_filter(self, model):
+    def get_group_filter(self, model, group=None, pks=None):
         """Get filter for the displayed group."""
-        group = self.kwargs["group"]  # type: ignore
-        pks = self.kwargs["pks"]  # type: ignore
-        if pks:  # type: ignore
+        if group is None:
+            group = self.kwargs["group"]
+        if pks is None:
+            pks = self.kwargs["pks"]
+
+        if pks and 0 not in pks:  # type: ignore
             if model == GROUP_MODEL_MAP.get(group):
                 # metadata only
                 rel = "pk"

codex/views/browser/mtime.py

@@ -0,0 +1,72 @@
+"""Get the mtimes for the submitted groups."""
+
+from types import MappingProxyType
+
+from rest_framework.response import Response
+
+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.filters.annotations import BrowserAnnotationsFilterView
+from codex.views.const import GROUP_MODEL_MAP
+
+LOG = get_logger(__name__)
+
+
+class MtimeView(BrowserAnnotationsFilterView):
+    """Get the mtimes for the submitted groups."""
+
+    input_serializer_class = GroupsMtimeSerializer
+    serializer_class = MtimeSerializer
+
+    REPARSE_JSON_FIELDS = frozenset({"groups", "filters"})
+
+    def __init__(self, *args, **kwargs) -> None:
+        """Initialize."""
+        super().__init__(*args, **kwargs)
+        self.init_bookmark_data()
+
+    def parse_params(self):
+        """Parse GET params."""
+        try:
+            validated_data = super().parse_params()
+            params = dict(self.params)
+            params["groups"] = validated_data["groups"]  # type: ignore
+            self.params = MappingProxyType(params)
+
+        except Exception:
+            LOG.exception("parse")
+            raise
+
+    def _get_group_mtime(self, item):
+        """Get one group's mtimes."""
+        group = item["group"]
+        pks = item["pks"]
+
+        model = GROUP_MODEL_MAP[group]
+        if not model:
+            model = Publisher
+
+        return self.get_group_mtime(model, group, pks)
+
+    def get_max_groups_mtime(self):
+        """Get max mtime for all groups."""
+        max_mtime = None
+
+        for item in self.params["groups"]:  # type: ignore
+            mtime = self._get_group_mtime(item)
+            max_mtime = max_none(max_mtime, mtime)
+        return max_mtime
+
+    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
+        result = {"max_mtime": max_mtime}
+        serializer = self.get_serializer(result)
+        return Response(serializer.data)

codex/views/const.py

@@ -1,9 +1,12 @@
 """Common view constants."""
 
+from datetime import datetime, timezone
 from types import MappingProxyType
 
 from django.contrib.auth.models import Group, User
 from django.contrib.sessions.models import Session
+from django.db.models.expressions import Value
+from django.db.models.fields import DateTimeField, PositiveSmallIntegerField
 
 from codex.models import (
     AgeRating,
@@ -127,3 +130,8 @@ CONFIG_MODELS = (
 )
 MAX_OBJ_PER_PAGE = 100
 GROUP_MTIME_MODEL_MAP = MappingProxyType({"r": Publisher, "a": StoryArc, "f": Folder})
+EPOCH_START = datetime.fromtimestamp(0, tz=timezone.utc)
+ONE_INTEGERFIELD = Value(1, PositiveSmallIntegerField())
+NONE_INTEGERFIELD = Value(None, PositiveSmallIntegerField())
+NONE_DATETIMEFIELD = Value(None, DateTimeField())
+EPOCH_START_DATETIMEFILED = Value(EPOCH_START)

codex/views/reader/books.py

@@ -1,6 +1,5 @@
 """Get Books methods."""
 
-from copy import deepcopy
 from typing import TYPE_CHECKING
 
 from django.db.models import F, IntegerField, Value
@@ -26,6 +25,10 @@ _COMIC_FIELDS = (
     "reading_direction",
     "updated_at",
 )
+_SHOW = {
+    "series": True,
+    "volume": True,
+}
 
 
 class ReaderBooksView(BookmarkBaseView, SessionView, SharedAnnotationsMixin):
@@ -134,13 +137,8 @@ class ReaderBooksView(BookmarkBaseView, SessionView, SharedAnnotationsMixin):
         )
         qs = self.annotate_group_names(qs, Comic)
         if arc_group == "s":
-            show = deepcopy(
-                self.get_from_session("show", session_key=self.BROWSER_SESSION_KEY)
-            )
-            show.pop("p", None)
-            show.pop("i", None)
             qs, comic_sort_names = self.alias_sort_names(
-                qs, Comic, pks=arc_pks, model_group="i", show=show
+                qs, Comic, pks=arc_pks, model_group="i", show=_SHOW
             )
             ordering = (
                 *comic_sort_names,
@@ -169,7 +167,7 @@ class ReaderBooksView(BookmarkBaseView, SessionView, SharedAnnotationsMixin):
         Yields 1 to 3 books
         """
         comics, arc_group = self._get_comics_list()
-        bookmark_filter = self.get_bookmark_filter()
+        bookmark_filter = self.get_bookmark_search_kwargs()
         books = {}
         prev_book = None
         pk = self.kwargs.get("pk")

codex/views/reader/reader.py

@@ -15,10 +15,11 @@ from codex.logger.logging import get_logger
 from codex.serializers.reader import ReaderArcSerializer, ReaderComicsSerializer
 from codex.serializers.redirect import ReaderRedirectSerializer
 from codex.views.reader.arcs import ReaderArcsView
-from codex.views.util import pop_name
+from codex.views.util import pop_name, reparse_json_query_params
 
 LOG = get_logger(__name__)
 _VALID_ARC_GROUPS = frozenset({"f", "s", "a"})
+_JSON_KEYS = frozenset({"arc"})
 
 
 class ReaderView(
@@ -47,26 +48,8 @@ class ReaderView(
         }
         raise NotFound(detail=detail)
 
-    def _parse_params(self):
-        data = self.request.GET
-        # Hack for query_parm parser
-        arc_data = MappingProxyType(
-            {"group": data.get("arc[group]"), "pks": data.get("arc[pks]")}
-        )
-        serializer = self.input_serializer_class(data=arc_data)
-        arc = {}
-        try:
-            serializer.is_valid()
-            arc: dict = serializer.validated_data  # type: ignore
-        except ValidationError:
-            pass
-
-        # PARAMS
-        top_group = self.get_from_session(
-            "top_group", "s", session_key=self.BROWSER_SESSION_KEY
-        )
-
-        # arc.group validation
+    def _validate_params(self, arc, top_group):
+        """arc.group validation."""
         # Can't be in the serializer
         arc_group = arc.get("group", "")
         if not arc_group:
@@ -79,6 +62,26 @@ class ReaderView(
         if arc_group not in _VALID_ARC_GROUPS:
             arc_group = None
 
+    def _parse_params(self):
+        data = self.request.GET
+        arc = {}
+        data = reparse_json_query_params(self.request.GET, _JSON_KEYS)
+        arc_data = data.get("arc", [])
+        if arc_data:
+            serializer = self.input_serializer_class(data=arc_data)
+            try:
+                serializer.is_valid()
+                arc: dict = serializer.validated_data  # type: ignore
+            except ValidationError:
+                pass
+
+        # From Browser Session
+        top_group = self.get_from_session(
+            "top_group", "s", session_key=self.BROWSER_SESSION_KEY
+        )
+
+        self._validate_params(arc, top_group)
+
         params = MappingProxyType(
             {
                 "arc": arc,

{codex-1.6.0a8.dist-info → codex-1.6.0a9.dist-info}/METADATA

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