codex 1.6.0a5__py3-none-any.whl → 1.6.0a7__py3-none-any.whl

codex/views/auth.py

@@ -1,25 +1,20 @@
 """Views authorization."""
 
-from types import MappingProxyType
-
-from django.conf import settings
 from django.contrib.auth.models import AnonymousUser
 from django.db.models import Q
 from drf_spectacular.utils import extend_schema
 from rest_framework.generics import GenericAPIView
-from rest_framework.mixins import RetrieveModelMixin
+from rest_framework.parsers import JSONParser
 from rest_framework.permissions import IsAuthenticated
 from rest_framework.response import Response
+from rest_framework.views import APIView
 
 from codex.logger.logging import get_logger
 from codex.models import AdminFlag, Comic, Folder, StoryArc, UserActive
-from codex.serializers.auth import AuthAdminFlagsSerializer, TimezoneSerializer
-from codex.serializers.choices import CHOICES
+from codex.serializers.auth import TimezoneSerializer
 from codex.serializers.mixins import OKSerializer
-from codex.views.const import GROUP_NAME_MAP
 
 LOG = get_logger(__name__)
-NULL_USER = {"pk": None, "username": None, "is_staff": False}
 
 
 class IsAuthenticatedOrEnabledNonUsers(IsAuthenticated):
@@ -37,20 +32,35 @@ class IsAuthenticatedOrEnabledNonUsers(IsAuthenticated):
         return super().has_permission(request, view)
 
 
-class TimezoneView(GenericAPIView):
+class AuthMixin:
+    """General Auth Policy."""
+
+    parser_classes = (JSONParser,)
+    permission_classes = (IsAuthenticatedOrEnabledNonUsers,)
+
+
+class AuthAPIView(AuthMixin, APIView):
+    """Auth Policy APIView."""
+
+
+class AuthGenericAPIView(AuthMixin, GenericAPIView):
+    """Auth Policy GenericAPIView."""
+
+
+class TimezoneView(AuthGenericAPIView):
     """User info."""
 
+    parser_classes = (JSONParser,)
     input_serializer_class = TimezoneSerializer
     serializer_class = OKSerializer
 
-    _AUTH_USER_MODEL_TYPE = type(settings.AUTH_USER_MODEL)
-
     @extend_schema(request=input_serializer_class)
     def post(self, request, *args, **kwargs):
         """Get the user info for the current user."""
-        serializer = self.input_serializer_class(data=self.request.data)
+        data = self.request.data  # type: ignore
+        serializer = self.input_serializer_class(data=data)
         serializer.is_valid(raise_exception=True)
-        request.session["django_timezone"] = serializer.validated_data["timezone"]
+        request.session["django_timezone"] = serializer.validated_data["timezone"]  # type: ignore
         request.session.save()
         user = self.request.user
         if user.is_authenticated:
@@ -59,48 +69,9 @@ class TimezoneView(GenericAPIView):
         return Response(serializer.data)
 
 
-class AdminFlagsView(GenericAPIView, RetrieveModelMixin):
-    """Get admin flags relevant to auth."""
-
-    _ADMIN_FLAG_KEYS = frozenset(
-        (
-            AdminFlag.FlagChoices.NON_USERS.value,
-            AdminFlag.FlagChoices.REGISTRATION.value,
-        )
-    )
-
-    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)
-
-
 class GroupACLMixin:
     """Filter group ACLS for views."""
 
-    ROOT_GROUP = "r"
-    FOLDER_GROUP = "f"
-    STORY_ARC_GROUP = "a"
-    COMIC_GROUP = "c"
-    GROUP_RELATION = MappingProxyType(
-        {
-            **GROUP_NAME_MAP,
-            COMIC_GROUP: "pk",
-            FOLDER_GROUP: "parent_folder",
-            STORY_ARC_GROUP: "story_arc_numbers__story_arc",
-        }
-    )
-
     def get_rel_prefix(self, model):
         """Return the relation prfiex for most fields."""
         prefix = ""
@@ -133,3 +104,11 @@ class GroupACLMixin:
             query |= auth_query
 
         return query
+
+
+class AuthFilterGenericAPIView(AuthGenericAPIView, GroupACLMixin):
+    """Auth Enabled GenericAPIView."""
+
+
+class AuthFilterAPIView(AuthAPIView, GroupACLMixin):
+    """Auth Enabled APIView."""

codex/views/bookmark.py

@@ -1,9 +1,6 @@
 """Bookmark views."""
 
-from typing import ClassVar
-
 from drf_spectacular.utils import extend_schema
-from rest_framework.generics import GenericAPIView
 from rest_framework.response import Response
 
 from codex.logger.logging import get_logger
@@ -12,13 +9,16 @@ 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 GROUP_RELATION
 
 LOG = get_logger(__name__)
 VERTICAL_READING_DIRECTIONS = frozenset({"ttb", "btt"})
 
 
-class BookmarkBaseView(GenericAPIView, GroupACLMixin):
+class BookmarkBaseView(AuthFilterGenericAPIView):
     """Bookmark Updater."""
 
     _BOOKMARK_UPDATE_FIELDS = (
@@ -160,12 +160,11 @@ class BookmarkBaseView(GenericAPIView, GroupACLMixin):
 class BookmarkView(BookmarkBaseView):
     """User Bookmark View."""
 
-    permission_classes: ClassVar[list] = [IsAuthenticatedOrEnabledNonUsers]  # type:ignore
     serializer_class = BookmarkSerializer
 
     def _validate(self, serializer_class):
         """Validate and translate the submitted data."""
-        data = self.request.data
+        data = self.request.data  # type: ignore
         if serializer_class:
             serializer = serializer_class(data=data, partial=True)
         else:
@@ -184,10 +183,7 @@ class BookmarkView(BookmarkBaseView):
 
         pks = self.kwargs.get("pks")
 
-        if group == "f":
-            relation = "folders__in"
-        else:
-            relation = self.GROUP_RELATION[group] + "__in"
+        relation = "folders__in" if group == "f" else GROUP_RELATION[group] + "__in"
         comic_filter = {relation: pks}
 
         self.update_bookmarks(updates, comic_filter=comic_filter)

codex/views/browser/{browser_annotations.py → annotations.py}

@@ -31,9 +31,10 @@ from codex.models import (
     Volume,
 )
 from codex.models.functions import JsonGroupArray
-from codex.views.browser.browser_order_by import (
+from codex.views.browser.order_by import (
     BrowserOrderByView,
 )
+from codex.views.const import STORY_ARC_GROUP
 from codex.views.mixins import SharedAnnotationsMixin
 
 _REL_MAP = MappingProxyType(
@@ -46,40 +47,39 @@ _REL_MAP = MappingProxyType(
         StoryArc: "story_arc_numbers__story_arc",
     }
 )
+_NONE_INTEGERFIELD = Value(None, PositiveSmallIntegerField())
+_NONE_DATETIMEFIELD = Value(None, DateTimeField())
+_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"}
+)
 
 
 class BrowserAnnotationsView(BrowserOrderByView, SharedAnnotationsMixin):
     """Base class for views that need special metadata annotations."""
 
-    _NONE_INTEGERFIELD = Value(None, PositiveSmallIntegerField())
-    _NONE_DATETIMEFIELD = Value(None, DateTimeField())
-    _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"})
-    )
-
     def __init__(self, *args, **kwargs):
         """Set params for the type checker."""
         super().__init__(*args, **kwargs)
@@ -92,7 +92,7 @@ class BrowserAnnotationsView(BrowserOrderByView, SharedAnnotationsMixin):
         """Get the group by for the model."""
         if model is None:
             model = self.model
-        return self._ALTERNATE_GROUP_BY.get(model, "sort_name")  # type: ignore
+        return _ALTERNATE_GROUP_BY.get(model, "sort_name")  # type: ignore
 
     def _alias_sort_names(self, qs, model):
         """Annotate sort_name."""
@@ -133,7 +133,7 @@ class BrowserAnnotationsView(BrowserOrderByView, SharedAnnotationsMixin):
         # Get story_arc__pk
         group = self.kwargs["group"]
         pks = self.kwargs["pks"]
-        if group == self.STORY_ARC_GROUP and pks:
+        if group == STORY_ARC_GROUP and pks:
             story_arc_pks = pks
         else:
             story_arc_pks = self.params.get("filters", {}).get(  # type: ignore
@@ -150,7 +150,7 @@ class BrowserAnnotationsView(BrowserOrderByView, SharedAnnotationsMixin):
             )
             story_arc_number = self.order_agg_func("selected_story_arc_number__number")
         else:
-            story_arc_number = self._NONE_INTEGERFIELD
+            story_arc_number = _NONE_INTEGERFIELD
 
         return qs.alias(story_arc_number=story_arc_number)
 
@@ -168,19 +168,30 @@ class BrowserAnnotationsView(BrowserOrderByView, SharedAnnotationsMixin):
             qs = qs.annotate(page_count=page_count_sum)
         return qs
 
-    def _annotate_bookmark_updated_at(self, qs, model):
-        if self.is_opds_1_acquisition or self.order_key == "bookmark_updated_at":
-            bm_rel = self.get_bm_rel(model)
-            bm_filter = self._get_my_bookmark_filter(bm_rel)
-            self.bm_annotation_data[model] = bm_rel, bm_filter  # type: ignore
+    def get_bookmark_updated_at_aggregate(self, model, always_max=False):
+        """Get The aggregate function for relevant bookmark.updated_at."""
+        bm_rel = self.get_bm_rel(model)
+        bm_filter = self.get_my_bookmark_filter(bm_rel)
+        self.bm_annotation_data[model] = bm_rel, bm_filter  # type: ignore
+
+        updated_at_rel = f"{bm_rel}__updated_at"
+        agg_func = Max if always_max else self.order_agg_func
+        return agg_func(
+            updated_at_rel,
+            default=_NONE_DATETIMEFIELD,
+            filter=bm_filter,
+        )
 
-            updated_at_rel = f"{bm_rel}__updated_at"
-            bookmark_updated_at_aggregate = self.order_agg_func(
-                updated_at_rel,
-                default=self._NONE_DATETIMEFIELD,
-                filter=bm_filter,
+    def _annotate_bookmark_updated_at(self, qs, model):
+        if (
+            self.is_opds_1_acquisition
+            or self.order_key == "bookmark_updated_at"
+            or self.is_bookmark_filtered
+        ):
+            bookmark_updated_at_aggregate = self.get_bookmark_updated_at_aggregate(
+                model
             )
-            if self.TARGET == "opds1":
+            if self.TARGET == "opds1" or self.is_bookmark_filtered:
                 qs = qs.annotate(bookmark_updated_at=bookmark_updated_at_aggregate)
             else:
                 qs = qs.alias(bookmark_updated_at=bookmark_updated_at_aggregate)
@@ -191,11 +202,11 @@ class BrowserAnnotationsView(BrowserOrderByView, SharedAnnotationsMixin):
         # Determine order func
         if model == Folder and self.order_key == "filename":
             order_value = F("name")
-        elif model == Comic or self.order_key in self._ANNOTATED_ORDER_FIELDS:
+        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 = self._ORDER_AGGREGATE_FUNCS[self.order_key]
+            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)
@@ -224,33 +235,49 @@ class BrowserAnnotationsView(BrowserOrderByView, SharedAnnotationsMixin):
         """Annotate the query set for the coverpath for the sort."""
         # Select comics for the children by an outer ref for annotation
         # Order the descendant comics by the sort argumentst
+        cover_style = self.params.get("cover_style")
         if model == Comic:
-            qs = qs.annotate(cover_pk=F("pk"), cover_mtime=F("updated_at"))
-        else:
-            cover_style = self.params.get("cover_style")
-            if cover_style == "i":
-                default_cover_pk = None
-                default_cover_mtime = None
+            default_cover_pk = F("pk")
+            default_cover_mtime = F("updated_at")
+        elif cover_style == "i":
+            default_cover_pk = None
+            default_cover_mtime = None
+        elif cover_style == "f":
+            # At this point it's only been filtered.
+            default_cover_pk = F(self.rel_prefix + "pk")
+            default_cover_mtime = F(self.rel_prefix + "updated_at")
+        else:  # cover_style == "d"
+            default_cover_pk = F(self.rel_prefix + "pk")
+            if self.is_bookmark_filtered:
+                default_cover_mtime = Case(
+                    When(bookmark_updated_at__gt=F(self.rel_prefix + "updated_at")),
+                    then=F("bookmark_updated_at"),
+                    default=F(self.rel_prefix + "updated_at"),
+                )
             else:
-                # At this point it's only been filtered.
-                default_cover_pk = F(self.rel_prefix + "pk")
                 default_cover_mtime = F(self.rel_prefix + "updated_at")
 
-            qs = qs.annotate(
-                cover_custom=F("custom_cover"),
-                cover_pk=Case(
-                    When(custom_cover__isnull=False, then=F("custom_cover__pk")),
-                    default=default_cover_pk,
-                ),
-                cover_mtime=Case(
-                    When(
-                        custom_cover__isnull=False, then=F("custom_cover__updated_at")
-                    ),
-                    default=default_cover_mtime,
-                ),
-                cover_pks=JsonGroupArray("cover_pk", distinct=True),
+        if model in (Volume, Comic):
+            cover_custom = Value(False)
+            cover_pk = default_cover_pk
+            cover_mtime = default_cover_mtime
+        else:
+            cover_custom = F("custom_cover")
+            cover_pk = Case(
+                When(custom_cover__isnull=False, then=F("custom_cover__pk")),
+                default=default_cover_pk,
             )
-        return qs
+            cover_mtime = Case(
+                When(custom_cover__isnull=False, then=F("custom_cover__updated_at")),
+                default=default_cover_mtime,
+            )
+
+        return qs.annotate(
+            cover_custom=cover_custom,
+            cover_pk=cover_pk,
+            cover_mtime=cover_mtime,
+            cover_pks=JsonGroupArray("cover_pk", distinct=True),
+        )
 
     def _annotate_group(self, qs, model):
         """Annotate Group."""
@@ -263,7 +290,7 @@ class BrowserAnnotationsView(BrowserOrderByView, SharedAnnotationsMixin):
             bm_rel, bm_filter = self.bm_annotation_data[model]  # type: ignore
         else:
             bm_rel = self.get_bm_rel(model)
-            bm_filter = self._get_my_bookmark_filter(bm_rel)
+            bm_filter = self.get_my_bookmark_filter(bm_rel)
 
         page_rel = f"{bm_rel}__page"
         finished_rel = f"{bm_rel}__finished"
@@ -340,6 +367,16 @@ class BrowserAnnotationsView(BrowserOrderByView, SharedAnnotationsMixin):
         progress = Case(When(page_count__gt=0, then=then), default=0.0)
         return qs.annotate(progress=progress)
 
+    def _annotate_mtime(self, qs):
+        """Annotations mtime."""
+        when_filter = {self.rel_prefix + "bookmark__updated_at__gt": F("updated_at")}
+        mtime = Case(
+            When(**when_filter),
+            then=F(self.rel_prefix + "bookmark__updated_at"),
+            default=F("updated_at"),
+        )
+        return qs.annotate(mtime=mtime)
+
     def annotate_card_aggregates(self, qs, model):
         """Annotate aggregates that appear the browser card."""
         qs = self._annotate_cover_pk(qs, model)
@@ -349,11 +386,8 @@ class BrowserAnnotationsView(BrowserOrderByView, SharedAnnotationsMixin):
         qs = self._annotate_group(qs, model)
         qs = self.annotate_group_names(qs, model)
         qs = self._annotate_bookmarks(qs, model)
-        return self._annotate_progress(qs)
-
-    def annotate_for_metadata(self, qs, _model):
-        """Annotations only for metadata."""
-        return qs.annotate(mtime=Max("updated_at"))
+        qs = self._annotate_progress(qs)
+        return self._annotate_mtime(qs)
 
     def _get_cover_pk_query(self, cover_pks, group_ids):
         """Get Cover Pk queryset for comic queryset."""
@@ -400,7 +434,8 @@ class BrowserAnnotationsView(BrowserOrderByView, SharedAnnotationsMixin):
         """Python hack to re-cover groups collapsed with group_by."""
         # This would be better in the main query but OuterRef can't access annotations.
         # So cover_pks aggregates all covers from multi groups like ids does.
-        if self.is_model_comic or self.params.get("cover_style") == "i":
+        cover_style = self.params.get("cover_style")
+        if self.is_model_comic or cover_style == "i":
             return group_qs
 
         recovered_group_list = []
@@ -408,15 +443,21 @@ class BrowserAnnotationsView(BrowserOrderByView, SharedAnnotationsMixin):
             cover_pks = group.cover_pks
             if len(cover_pks) == 1:
                 cover_pk = cover_pks[0]
-                cover_updated_at = group.updated_at
             else:
                 comic_qs = self._get_cover_pk_query(cover_pks, group.ids)
                 # print(comic_qs.explain())
                 # print(comic_qs.query)
                 cover = comic_qs[0]
                 cover_pk = cover.pk
-                cover_updated_at = cover.updated_at
+
+            if len(group.ids) == 1:
+                cover_mtime = group.updated_at
+            else:
+                cover_mtime = group.__class__.objects.filter(
+                    pk__in=group.ids
+                ).aggregate(updated_at=Max("updated_at"))["updated_at"]
+
+            group.cover_mtime = cover_mtime
             group.cover_pk = cover_pk
-            group.cover_mtime = cover_updated_at
             recovered_group_list.append(group)
         return recovered_group_list

codex/views/browser/base.py

@@ -1,16 +1,11 @@
 """Views for browsing comic library."""
 
-import json
-from copy import deepcopy
 from types import MappingProxyType
-from typing import Any
-from urllib.parse import unquote_plus
+from typing import TYPE_CHECKING, Any
 
 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
@@ -18,43 +13,25 @@ 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.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
+from codex.views.browser.filters.search import SearchFilterView
+from codex.views.const import GROUP_MODEL_MAP, ROOT_GROUP
+from codex.views.utils import reparse_json_query_params
 
 LOG = get_logger(__name__)
 
+if TYPE_CHECKING:
+    from codex.models.groups import BrowserGroupModel
 
-class BrowserBaseView(
-    ComicFieldFilter, BookmarkFilterMixin, GroupFilterMixin, SearchFilterMixin
-):
+_REPARSE_JSON_FIELDS = frozenset({"filters", "show"})
+
+
+class BrowserBaseView(SearchFilterView):
     """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({})
 
     _GET_JSON_KEYS = frozenset({"filters", "show"})
@@ -73,6 +50,7 @@ class BrowserBaseView(
         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."""
@@ -95,7 +73,7 @@ class BrowserBaseView(
     def get_model_group(self):
         """Determine model group for set_browse_model()."""
         group = self.kwargs["group"]
-        if group == self.ROOT_GROUP:
+        if group == ROOT_GROUP:
             group = self.params["top_group"]
         return group
 
@@ -104,7 +82,7 @@ class BrowserBaseView(
         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)
+        object_filter &= self.get_comic_field_filter(model)
         return object_filter
 
     def get_query_filters(self, model, choices=False):
@@ -113,47 +91,21 @@ class BrowserBaseView(
         object_filter &= self.get_group_filter(choices)
         return object_filter
 
-    def _parse_query_params(self, query_params):
+    def _parse_query_params(self):
         """Parse GET query parameters: filter object & snake case."""
-        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)
+        query_params = reparse_json_query_params(self.request.GET, _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
 
     def parse_params(self):
         """Validate sbmitted settings and apply them over the session settings."""
-        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 = {}
-
+        data = self._parse_query_params()
         serializer = self.input_serializer_class(data=data)
         serializer.is_valid(raise_exception=True)
-
-        params = deepcopy(self.request.session[self.SESSION_KEY])
-        params.update(serializer.validated_data)
-        self.params = MappingProxyType(params)
+        self.load_params_from_session(serializer.validated_data)
+        self.is_bookmark_filtered = bool(self.params.get("filters", {}).get("bookmark"))
 
     def set_order_key(self):
         """Unused until browser."""
@@ -164,10 +116,10 @@ class BrowserBaseView(
     def set_model(self):
         """Set the model for the browse list."""
         group = self.kwargs["group"]
-        self.group_class = self.GROUP_MODEL_MAP[group]
+        self.group_class = GROUP_MODEL_MAP[group]
 
         self.model_group = self.get_model_group()
-        self.model = self.GROUP_MODEL_MAP.get(self.model_group)
+        self.model = GROUP_MODEL_MAP.get(self.model_group)
         if self.model is None:
             detail = f"Cannot browse {group=}"
             LOG.debug(detail)