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

codex/views/browser/base.py

@@ -1,41 +1,71 @@
 """Views for browsing comic library."""
 
+import json
+from copy import deepcopy
 from types import MappingProxyType
-from typing import TYPE_CHECKING, Any
+from typing import Any
+from urllib.parse import unquote_plus
 
 from django.contrib.auth.models import User
+from django.db.models import Q
 from django.db.models.aggregates import Max, Min
+from djangorestframework_camel_case.settings import api_settings
+from djangorestframework_camel_case.util import underscoreize
 from rest_framework.exceptions import NotFound
 
 from codex.logger.logging import get_logger
 from codex.models import (
     AdminFlag,
     Comic,
+    Folder,
+    Imprint,
+    Publisher,
+    Series,
+    StoryArc,
+    Volume,
 )
+from codex.models.groups import BrowserGroupModel
 from codex.serializers.browser.settings import BrowserSettingsSerializer
-from codex.views.browser.filters.search import SearchFilterView
-from codex.views.const import FOLDER_GROUP, GROUP_MODEL_MAP, ROOT_GROUP, STORY_ARC_GROUP
-from codex.views.util import reparse_json_query_params
+from codex.views.browser.filters.bookmark import BookmarkFilterMixin
+from codex.views.browser.filters.field import ComicFieldFilter
+from codex.views.browser.filters.group import GroupFilterMixin
+from codex.views.browser.filters.search import SearchFilterMixin
 
 LOG = get_logger(__name__)
 
-if TYPE_CHECKING:
-    from codex.models.groups import BrowserGroupModel
 
-
-class BrowserBaseView(SearchFilterView):
+class BrowserBaseView(
+    ComicFieldFilter, BookmarkFilterMixin, GroupFilterMixin, SearchFilterMixin
+):
     """Browse comics with a variety of filters and sorts."""
 
     input_serializer_class = BrowserSettingsSerializer
 
+    GROUP_MODEL_MAP: MappingProxyType[str, type[BrowserGroupModel] | None] = (
+        MappingProxyType(
+            {
+                GroupFilterMixin.ROOT_GROUP: None,
+                "p": Publisher,
+                "i": Imprint,
+                "s": Series,
+                "v": Volume,
+                GroupFilterMixin.COMIC_GROUP: Comic,
+                GroupFilterMixin.FOLDER_GROUP: Folder,
+                GroupFilterMixin.STORY_ARC_GROUP: StoryArc,
+            }
+        )
+    )
     ADMIN_FLAG_VALUE_KEY_MAP = MappingProxyType({})
-    REPARSE_JSON_FIELDS = frozenset({"breadcrumbs", "filters", "show"})
+
+    _GET_JSON_KEYS = frozenset({"filters", "show"})
+    TARGET = ""
 
     def __init__(self, *args, **kwargs):
         """Set params for the type checker."""
         super().__init__(*args, **kwargs)
         self._is_admin: bool = False
         self.params: MappingProxyType[str, Any] = MappingProxyType({})
+        self.bm_annotation_data = {}
         self.rel_prefix: str = ""
         self.model: type[BrowserGroupModel] | None = None
         self.group_class: type[BrowserGroupModel] | None = None
@@ -43,7 +73,6 @@ class BrowserBaseView(SearchFilterView):
         self.is_model_comic: bool = False
         self.admin_flags: MappingProxyType[str, bool] = MappingProxyType({})
         self.order_agg_func: type[Min | Max] = Min
-        self.order_key: str = ""
 
     def is_admin(self):
         """Is the current user an admin."""
@@ -66,46 +95,65 @@ class BrowserBaseView(SearchFilterView):
     def get_model_group(self):
         """Determine model group for set_browse_model()."""
         group = self.kwargs["group"]
-        if group == ROOT_GROUP:
+        if group == self.ROOT_GROUP:
             group = self.params["top_group"]
         return group
 
-    def _parse_query_params(self):
+    def get_query_filters_without_group(self, model, cover=False):
+        """Return all the filters except the group filter."""
+        add_acl = not (cover and self.model == Folder)  # type: ignore
+        object_filter = self.get_group_acl_filter(model) if add_acl else Q()
+        object_filter &= self.get_bookmark_filter(model)
+        object_filter &= self.get_comic_field_filter(self.rel_prefix)
+        return object_filter
+
+    def get_query_filters(self, model, choices=False):
+        """Return the main object filter and the one for aggregates."""
+        object_filter = self.get_query_filters_without_group(model)
+        object_filter &= self.get_group_filter(choices)
+        return object_filter
+
+    def _parse_query_params(self, query_params):
         """Parse GET query parameters: filter object & snake case."""
-        query_params = reparse_json_query_params(
-            self.request.GET, self.REPARSE_JSON_FIELDS
-        )
-        if "q" not in query_params and (query := query_params.get("query")):
-            # parse query param for opds v2
-            query_params["q"] = query
-        return query_params
+        result = {}
+        for key, val in query_params.items():
+            if key in self._GET_JSON_KEYS:
+                unquoted_val = unquote_plus(val)  # for pocketbooks reader
+                parsed_val = json.loads(unquoted_val)
+                if not parsed_val:
+                    continue
+                parsed_key = key
+            elif key in ("q", "query"):
+                # parse and strip query param
+                # "query" is used by opds v2
+                if "q" in result:
+                    continue
+                parsed_val = val.strip()
+                if not parsed_val:
+                    continue
+                parsed_key = "q"
+            else:
+                parsed_key = key
+                parsed_val = val
+
+            result[parsed_key] = parsed_val
+        return underscoreize(result, **api_settings.JSON_UNDERSCOREIZE)
 
     def parse_params(self):
         """Validate sbmitted settings and apply them over the session settings."""
-        data = self._parse_query_params()
-        serializer = self.input_serializer_class(data=data)
-        serializer.is_valid(raise_exception=True)
+        if self.request.method == "GET":
+            data = self._parse_query_params(self.request.GET)
+        elif hasattr(self.request, "data"):
+            data = self._parse_query_params(self.request.data)
+        else:
+            data = {}
 
-        params: dict[str, Any] = {}
-        defaults = self.SESSION_DEFAULTS[self.SESSION_KEY]
-        params.update(defaults)
-        group = self.kwargs.get("group")
-        if group:
-            # order_by has a dynamic group based default
-            order_defaults = {
-                "order_by": "filename"
-                if group == FOLDER_GROUP
-                else "story_arc_number"
-                if group == STORY_ARC_GROUP
-                else "sort_name"
-            }
-            params.update(order_defaults)
-        validated_data = serializer.validated_data
+        serializer = self.input_serializer_class(data=data)
 
-        if validated_data:
-            params.update(validated_data)  # type: ignore
+        serializer.is_valid(raise_exception=True)
+        params = deepcopy(dict(self.SESSION_DEFAULTS))
+        params.update(serializer.validated_data)
         self.params = MappingProxyType(params)
-        self.is_bookmark_filtered = bool(self.params.get("filters", {}).get("bookmark"))
 
     def set_order_key(self):
         """Unused until browser."""
@@ -116,10 +164,10 @@ class BrowserBaseView(SearchFilterView):
     def set_model(self):
         """Set the model for the browse list."""
         group = self.kwargs["group"]
-        self.group_class = GROUP_MODEL_MAP[group]
+        self.group_class = self.GROUP_MODEL_MAP[group]
 
         self.model_group = self.get_model_group()
-        self.model = GROUP_MODEL_MAP.get(self.model_group)
+        self.model = self.GROUP_MODEL_MAP.get(self.model_group)
         if self.model is None:
             detail = f"Cannot browse {group=}"
             LOG.debug(detail)