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

codex/views/browser/browser.py

@@ -1,15 +1,14 @@
 """Views for browsing comic library."""
 
 from copy import deepcopy
-from math import ceil
+from math import ceil, floor, log10
+from os import sep
+from pathlib import Path
 from types import MappingProxyType
-from typing import ClassVar
+from typing import TYPE_CHECKING, ClassVar
 
 from django.core.paginator import EmptyPage, Paginator
-from django.db.models import F, Max, Value
-from django.db.models.fields import (
-    CharField,
-)
+from django.db.models import Max
 from drf_spectacular.utils import extend_schema
 from rest_framework.response import Response
 
@@ -31,27 +30,33 @@ from codex.models import (
 from codex.serializers.browser.page import BrowserPageSerializer
 from codex.serializers.choices import DEFAULTS
 from codex.views.auth import IsAuthenticatedOrEnabledNonUsers
-from codex.views.browser.browser_annotations import BrowserAnnotationsView
+from codex.views.browser.browser_breadcrumbs import BrowserBreadcrumbsView
 from codex.views.browser.const import MAX_OBJ_PER_PAGE
 
+if TYPE_CHECKING:
+    from django.db.models.query import QuerySet
+
+
 LOG = get_logger(__name__)
-_ADMIN_FLAG_VALUE_KEY_MAP = MappingProxyType(
-    {
-        AdminFlag.FlagChoices.FOLDER_VIEW.value: "folder_view",
-        AdminFlag.FlagChoices.IMPORT_METADATA.value: "import_metadata",
-    }
-)
 
 
-class BrowserView(BrowserAnnotationsView):
+class BrowserView(BrowserBreadcrumbsView):
     """Browse comics with a variety of filters and sorts."""
 
     permission_classes: ClassVar[list] = [IsAuthenticatedOrEnabledNonUsers]  # type: ignore
     serializer_class = BrowserPageSerializer
 
-    _NAV_GROUPS = "rpisv"
+    ADMIN_FLAG_VALUE_KEY_MAP = MappingProxyType(
+        {
+            AdminFlag.FlagChoices.FOLDER_VIEW.value: "folder_view",
+            AdminFlag.FlagChoices.IMPORT_METADATA.value: "import_metadata",
+            AdminFlag.FlagChoices.DYNAMIC_GROUP_COVERS.value: "dynamic_group_covers",
+        }
+    )
 
-    _GROUP_INSTANCE_SELECT_RELATED = MappingProxyType(
+    _GROUP_INSTANCE_SELECT_RELATED: MappingProxyType[
+        type[BrowserGroupModel], tuple[str | None, ...]
+    ] = MappingProxyType(
         {
             Comic: ("series", "volume"),
             Volume: ("series",),
@@ -65,7 +70,7 @@ class BrowserView(BrowserAnnotationsView):
     DEFAULT_ROUTE = MappingProxyType(
         {
             "name": "browser",
-            "params": deepcopy(DEFAULTS["route"]),
+            "params": deepcopy(DEFAULTS["breadcrumbs"][0]),
         }
     )
     _OPDS_M2M_RELS = (
@@ -81,39 +86,29 @@ class BrowserView(BrowserAnnotationsView):
         "contributors__role",
         "contributors__person",
     )
+    TARGET = "browser"
+
+    def __init__(self, *args, **kwargs):
+        """Set params for the type checker."""
+        super().__init__(*args, **kwargs)
+        self.is_opds_2_acquisition = False
+        self.group_query: QuerySet = Comic.objects.none()
+        self.group_instance: BrowserGroupModel | None = None
+        self.valid_nav_groups: tuple[str, ...] = ()
+        self.cover_search_score_pairs: tuple[tuple[int, float], ...] = ()
+
+    def _raise_redirect(self, reason, route_mask=None, settings_mask=None):
+        """Redirect the client to a valid group url."""
+        route = deepcopy(dict(self.DEFAULT_ROUTE))
+        if route_mask:
+            route["params"].update(route_mask)  # type: ignore
+        settings = deepcopy(dict(self.params))
+        if settings_mask:
+            settings.update(settings_mask)
+        detail = {"route": route, "settings": settings, "reason": reason}
+        raise SeeOtherRedirectError(detail=detail)
 
-    is_opds_2_acquisition = False
-
-    def _annotate_group_names(self, queryset, model):
-        """Annotate name fields by hoisting them up."""
-        # Optimized to only lookup what is used on the frontend
-        group_names = {}
-        if model == Comic:
-            group_names = {
-                "publisher_name": F("publisher__name"),
-                "series_name": F("series__name"),
-                "volume_name": F("volume__name"),
-            }
-            if self.is_opds_2_acquisition:
-                group_names["imprint_name"] = F("imprint__name")
-        elif model == Volume:
-            group_names["series_name"] = F("series__name")
-        elif model == Imprint:
-            group_names["publisher_name"] = F("publisher__name")
-        return queryset.annotate(**group_names)
-
-    def _annotate_group(self, queryset, model):
-        """Annotate Group."""
-        value = "c" if model == Comic else self.model_group
-        return queryset.annotate(group=Value(value, CharField(max_length=1)))
-
-    def _add_annotations(self, queryset, model, search_scores: dict):
-        """Annotations for display and sorting."""
-        queryset = self.annotate_common_aggregates(queryset, model, search_scores)
-        queryset = self._annotate_group(queryset, model)
-        return self._annotate_group_names(queryset, model)
-
-    def _get_model_group(self):
+    def get_model_group(self):
         """Get the group of the models to browse."""
         # the model group shown must be:
         #   A valid nav group or 'c'
@@ -122,118 +117,77 @@ class BrowserView(BrowserAnnotationsView):
         if group == self.FOLDER_GROUP:
             return group
         if group == self.STORY_ARC_GROUP:
-            pk = self.kwargs["pk"]
-            return self.COMIC_GROUP if pk else group
+            pks = self.kwargs.get("pks")
+            return self.COMIC_GROUP if pks else group
         if group == self.valid_nav_groups[-1]:
             # special case for lowest valid group
             return self.COMIC_GROUP
         return self.valid_nav_groups[self.valid_nav_groups.index(group) + 1]
 
-    def _set_browse_model(self):
-        """Set the model for the browse list."""
-        group = self.kwargs["group"]
-        self.group_class = self.GROUP_MODEL_MAP[group]
-
-        self.model_group = self._get_model_group()
-        self.model = self.GROUP_MODEL_MAP[self.model_group]
-
-    def _get_common_queryset(self, model, search_scores):
+    def _get_common_queryset(self, model):
         """Create queryset common to group & books."""
-        object_filter = self.get_query_filters(model, search_scores, False)
+        object_filter = self.get_query_filters(model, False)
         qs = model.objects.filter(object_filter)
-        qs = self._add_annotations(qs, model, search_scores)
-        qs = self.add_order_by(qs, model)
-        if limit := self.params.get("limit"):
-            # limit only is set by some opds views
-            qs = qs[:limit]
-        return qs
-
-    def _get_group_queryset(self, search_scores: dict | None):
+        qs = self.filter_by_annotations(qs, model)
+        count_group_by = self.get_group_by(model)
+        count = qs.group_by(count_group_by).count()
+        if count:
+            qs = self.annotate_order_aggregates(qs, model)
+            qs = self.add_order_by(qs, model)
+            if limit := self.params.get("limit"):
+                # limit only is set by some opds views
+                qs = qs[:limit]
+                count = min(count, limit)  # type: ignore
+
+        return qs, count
+
+    def _get_group_queryset(self):
         """Create group queryset."""
         if not self.model:
             reason = "Model not set for browser queryset."
             raise ValueError(reason)
-        if self.model == Comic or search_scores is None:
+        elif self.is_model_comic:  # noqa: RET506
             qs = self.model.objects.none()
+            count = 0
         else:
-            qs = self._get_common_queryset(self.model, search_scores)
-        return qs
+            qs, count = self._get_common_queryset(self.model)
+            group_by = self.get_group_by()
+            qs = qs.group_by(group_by)
+        return qs, count
 
-    def _get_book_queryset(self, search_scores: dict | None):
+    def _get_book_queryset(self):
         """Create book queryset."""
-        if self.model in (Comic, Folder) and search_scores is not None:
-            qs = self._get_common_queryset(Comic, search_scores)
+        if self.model in (Comic, Folder):
+            qs, count = self._get_common_queryset(Comic)
         else:
             qs = Comic.objects.none()
-        return qs
+            count = 0
+        return qs, count
 
-    def _get_folder_up_route(self):
-        """Get out parent's pk."""
-        up_group = self.FOLDER_GROUP
-        up_pk = None
-
-        # Recall root id & relative path from way back in
-        # object creation
-        if self.group_instance and isinstance(self.group_instance, Folder):
-            if self.group_instance.parent_folder:
-                up_pk = self.group_instance.parent_folder.pk
-            else:
-                up_pk = 0
-
-        return up_group, up_pk
-
-    def _get_story_arc_up_route(self):
-        """Get one level hierarchy."""
-        up_group = self.STORY_ARC_GROUP
-        up_group = 0 if self.group_instance else None
-        return self.STORY_ARC_GROUP, up_group
-
-    def _set_group_instance(self):
+    def _set_group_query_and_instance(self):
         """Create group_class instance."""
-        pk = self.kwargs.get("pk")
-        if pk and self.group_class:
+        pks = self.kwargs.get("pks")
+        if pks and self.group_class:
             try:
-                select_related: tuple[str, ...] = self._GROUP_INSTANCE_SELECT_RELATED[
-                    self.group_class
-                ]  # type: ignore
-                self.group_instance: BrowserGroupModel | None = (
-                    self.group_class.objects.select_related(*select_related).get(pk=pk)
+                select_related: tuple[str | None, ...] = (
+                    self._GROUP_INSTANCE_SELECT_RELATED[self.group_class]
                 )
+                self.group_query = self.group_class.objects.select_related(
+                    *select_related
+                ).filter(pk__in=pks)
             except self.group_class.DoesNotExist:
                 group = self.kwargs.get("group")
                 page = self.kwargs.get("page")
-                if group == "r" and pk == 0 and page == 1:
-                    self.group_instance: BrowserGroupModel | None = None
+                if group == "r" and not pks and page == 1:
+                    self.group_query = self.group_class.objects.none()
                 else:
-                    reason = f"{group}={pk} does not exist!"
-                    self._raise_redirect({"group": group, "pk": 0, "page": 1}, reason)
-        else:
-            self.group_instance: BrowserGroupModel | None = None
-
-    def _get_browse_up_route(self):
-        """Get the up route from the first valid ancestor."""
-        # Ancestor group
-        group = self.kwargs.get("group")
-        if self.valid_nav_groups.index(group) > 0:
-            ancestor_group = self.valid_nav_groups[
-                self.valid_nav_groups.index(group) - 1
-            ]
+                    reason = f"{group}__in={pks} does not exist!"
+                    self._raise_redirect(reason, route_mask={"group": group})
+        elif self.group_class:
+            self.group_query = self.group_class.objects.none()
         else:
-            ancestor_group = None
-
-        up_group = ancestor_group
-        up_pk = None
-
-        # Ancestor pk
-        pk = self.kwargs.get("pk")
-        if up_group == self.ROOT_GROUP or pk == 0:
-            up_pk = 0
-        elif up_group:
-            # get the ancestor pk from the current group
-            up_relation = self.GROUP_RELATION[up_group]
-            up_pk = getattr(self.group_instance, up_relation).pk
-
-        return up_group, up_pk
+            self.group_query = Comic.objects.none()
+        self.group_instance = self.group_query.first()
 
     def _get_root_group_name(self):
         if not self.model:
@@ -248,66 +202,69 @@ class BrowserView(BrowserAnnotationsView):
     def _get_folder_parent_name(self):
         """Get title for a folder browser page."""
         group_instance: Folder = self.group_instance  # type: ignore
-        folder_path = group_instance.path
-        if not folder_path:
+        if not group_instance.path:
             return ""
 
-        parent_name = folder_path
-        prefix = group_instance.library.path
-        if prefix[-1] != "/":
-            prefix += "/"
+        parent_path = Path(group_instance.path).parent
         if not self.is_admin():
-            # remove library path for not admins
-            parent_name = parent_name.removeprefix(prefix)
-        suffix = "/" + group_instance.name
-        return parent_name.removesuffix(suffix)
+            try:
+                # remove library path for not admins
+                library_path_parent = Path(group_instance.library.path).parent
+                parent_path = parent_path.relative_to(library_path_parent)
+            except ValueError:
+                parent_path = ""
+
+        parent_path_str = str(parent_path)
+        parent_path_str = parent_path_str.removeprefix(".")
+        if parent_path_str and parent_path_str[0] != sep:
+            parent_path_str = sep + parent_path_str
+        return parent_path_str
 
     def _get_browser_page_title(self):
         """Get the proper title for this browse level."""
-        pk = self.kwargs.get("pk")
-        parent_name = ""
         group_count = 0
         group_name = ""
-        if pk == 0:
+        pks = self.kwargs.get("pks")
+        if not pks:
             group_name = self._get_root_group_name()
-        elif self.group_instance:
-            if isinstance(self.group_instance, Imprint):
-                parent_name = self.group_instance.publisher.name
-            elif isinstance(self.group_instance, Volume):
-                parent_name = self.group_instance.series.name
-                group_count = self.group_instance.series.volume_count
-            elif isinstance(self.group_instance, Comic):
-                group_count = self.group_instance.volume.issue_count
-            elif isinstance(self.group_instance, Folder):
-                parent_name = self._get_folder_parent_name()
-            group_name = self.group_instance.name
+        else:
+            group_instance = self.group_instance
+            if group_instance:
+                if isinstance(group_instance, Volume):
+                    group_count = group_instance.series.volume_count
+                elif isinstance(group_instance, Comic):
+                    group_count = group_instance.volume.issue_count
+                group_name = group_instance.name
 
         return {
-            "parent_name": parent_name,
             "group_name": group_name,
             "group_count": group_count,
         }
 
-    def _page_out_of_bounds(self, num_pages):
+    def _check_page_in_bounds(self, total_count):
         """Redirect page out of bounds."""
-        group = self.kwargs.get("group")
-        pk = self.kwargs.get("pk", 0)
+        pks = self.kwargs.get("pks")
         page = self.kwargs.get("page", 1)
-        if group == "r" and pk == 0 and page == 1:
-            # Don't redirect if on the root page.
-            return
+        num_pages = ceil(total_count / MAX_OBJ_PER_PAGE)
+        if (not pks and page == 1) or (page >= 1 and page <= num_pages):
+            # Don't redirect if on the root page for the group.
+            # Or page within valid range.
+            return num_pages
 
-        if num_pages:
-            new_page = num_pages if page > num_pages else 1
+        # Adjust route mask for redirect
+        group = self.kwargs.get("group")
+        if num_pages and page > 1:
+            # Try page 1 first.
+            new_page = num_pages if num_pages and page > num_pages else 1
+            pks = pks if pks else "0"
         else:
-            # Redirect to root.
-            group = "r"
-            pk = 0
+            # Redirect to root for the group.
+            pks = "0"
             new_page = 1
-        route_changes = {"group": group, "pk": pk, "page": new_page}
+
         reason = f"{page=} does not exist!"
-        LOG.debug(f"{reason} redirect to page {new_page}.")
-        self._raise_redirect(route_changes, reason)
+        route_changes = {"group": group, "pks": pks, "page": new_page}
+        return self._raise_redirect(reason, route_mask=route_changes)
 
     def _paginate_section(self, model, qs, page):
         """Paginate a group or Comic section."""
@@ -359,64 +316,62 @@ class BrowserView(BrowserAnnotationsView):
                 )
         return page_book_qs
 
-    def _paginate(self, group_qs, book_qs):
+    def _paginate(self, group_qs, book_qs, group_count, book_count):
         """Paginate the queryset into a group and book object lists."""
-        page = self.kwargs.get("page", 1)
-        if page < 1:
-            self._page_out_of_bounds(1)
-
-        page_obj_count = 0
+        num_pages = self._check_page_in_bounds(group_count + book_count)
+        page_group_qs = self._paginate_groups(group_qs, group_count)
+        page_group_count = page_group_qs.count()
+        page_book_qs = self._paginate_books(book_qs, group_count, page_group_count)
+        page_book_count = page_book_qs.count()
 
-        group_count = group_qs.count()
-        book_count = book_qs.count()
+        return page_group_qs, page_book_qs, num_pages, page_group_count, page_book_count
 
-        num_pages = ceil((group_count + book_count) / MAX_OBJ_PER_PAGE)
-        if page > num_pages:
-            self._page_out_of_bounds(num_pages)
+    @staticmethod
+    def _get_zero_pad(book_qs):
+        """Get the zero padding for the display."""
+        issue_number_max = book_qs.only("issue_number").aggregate(Max("issue_number"))[
+            "issue_number__max"
+        ]
+        zero_pad = 1
+        if issue_number_max:
+            zero_pad += floor(log10(issue_number_max))
+        return zero_pad
+
+    def _get_group_and_books(self):
+        """Create the main queries with filters, annotation and pagination."""
+        group_qs, group_count = self._get_group_queryset()
+        book_qs, book_count = self._get_book_queryset()
+        # Paginate
+        group_qs, book_qs, num_pages, page_group_count, page_book_count = (
+            self._paginate(group_qs, book_qs, group_count, book_count)
+        )
+        if page_group_count:
+            group_qs = self.annotate_card_aggregates(group_qs, self.model)
+        if page_book_count:
+            zero_pad = self._get_zero_pad(book_qs)
+            book_qs = self.annotate_card_aggregates(book_qs, Comic)
+        else:
+            zero_pad = 1
 
-        page_group_qs = self._paginate_groups(group_qs, group_count)
-        page_obj_count += page_group_qs.count()
-        page_book_qs = self._paginate_books(book_qs, group_count, page_obj_count)
-        page_obj_count += page_book_qs.count()
+        # print(group_qs.explain())
+        # print(group_qs.query)
 
-        return page_group_qs, page_book_qs, num_pages, page_obj_count
+        recovered_group_list = self.re_cover_multi_groups(group_qs)
+        total_count = page_group_count + page_book_count
+        return recovered_group_list, book_qs, num_pages, total_count, zero_pad
 
     def get_object(self):
         """Validate settings and get the querysets."""
-        self._set_browse_model()
-        self.set_rel_prefix(self.model)
-        self._set_group_instance()  # Placed up here to invalidate earlier
-        # Create the main query with the filters
-        search_scores: dict | None = self.get_search_scores()
-        group = self.kwargs.get("group")
-
-        group_qs = self._get_group_queryset(search_scores)
-        book_qs = self._get_book_queryset(search_scores)
-
-        # Paginate
-        group_qs, book_qs, num_pages, total_count = self._paginate(group_qs, book_qs)
+        group_list, book_qs, num_pages, total_count, zero_pad = (
+            self._get_group_and_books()
+        )
 
         # get additional context
-        if group == self.FOLDER_GROUP:
-            up_group, up_pk = self._get_folder_up_route()
-        elif group == self.STORY_ARC_GROUP:
-            up_group, up_pk = self._get_story_arc_up_route()
-        else:
-            up_group, up_pk = self._get_browse_up_route()
-        browser_page_title = self._get_browser_page_title()
-
-        if up_group is not None and up_pk is not None:
-            up_route = {"group": up_group, "pk": up_pk, "page": 1}
-        else:
-            up_route = {}
-
-        libraries_exist = Library.objects.exists()
-
+        parent_breadcrumbs = self.get_parent_breadcrumbs()
+        title = self._get_browser_page_title()
+        # needs to happen after pagination
         # runs obj list query twice :/
-        issue_number_max = book_qs.only("issue_number").aggregate(Max("issue_number"))[
-            "issue_number__max"
-        ]
-
+        libraries_exist = Library.objects.exists()
         covers_timestamp = int(
             Timestamp.objects.get(
                 key=Timestamp.TimestampChoices.COVERS.value
@@ -426,12 +381,12 @@ class BrowserView(BrowserAnnotationsView):
         # construct final data structure
         return MappingProxyType(
             {
-                "up_route": up_route,
-                "browser_title": browser_page_title,
+                "breadcrumbs": parent_breadcrumbs,
+                "title": title,
                 "model_group": self.model_group,
-                "groups": group_qs,
+                "groups": group_list,
                 "books": book_qs,
-                "issue_number_max": issue_number_max,
+                "zero_pad": zero_pad,
                 "num_pages": num_pages,
                 "total_count": total_count,
                 "admin_flags": self.admin_flags,
@@ -440,23 +395,41 @@ class BrowserView(BrowserAnnotationsView):
             }
         )
 
-    def _get_valid_top_groups(self):
+    def _get_valid_browse_top_groups(self):
         """Get valid top groups for the current settings.
 
         Valid top groups are determined by the Browser Settings.
         """
         valid_top_groups = []
 
-        show: MappingProxyType = self.params["show"]  # type:ignore
-        for nav_group in self._NAV_GROUPS:
-            if show.get(nav_group):
+        show = self.params["show"]
+        for nav_group, allowed in show.items():
+            if allowed:
                 valid_top_groups.append(nav_group)
         # Issues is always a valid top group
         valid_top_groups += [self.COMIC_GROUP]
 
         return valid_top_groups
 
-    def _set_valid_browse_nav_groups(self, valid_top_groups):
+    def _validate_top_group(self, valid_top_groups):
+        nav_group = self.kwargs.get("group")
+        top_group = self.params.get("top_group")
+        if top_group not in valid_top_groups:
+            reason = f"top_group {top_group} not in valid nav groups, changed to "
+            if nav_group in valid_top_groups:
+                valid_top_group = nav_group
+                reason += "nav group: "
+            else:
+                valid_top_group = valid_top_groups[0]
+                reason += "first valid top group "
+            reason += valid_top_group
+            pks = self.kwargs.get("pks", ())
+            page = self.kwargs["page"]
+            route = {"group": nav_group, "pks": pks, "page": page}
+            settings_mask = {"top_group": valid_top_group}
+            self._raise_redirect(reason, route, settings_mask)
+
+    def set_valid_browse_nav_groups(self, valid_top_groups):
         """Get valid nav groups for the current settings.
 
         Valid nav groups are the top group and below that are also
@@ -466,137 +439,90 @@ class BrowserView(BrowserAnnotationsView):
         """
         top_group = self.params["top_group"]
         nav_group = self.kwargs["group"]
-        self.valid_nav_groups = (self.ROOT_GROUP,)
+        valid_nav_groups = [self.ROOT_GROUP]
 
         for possible_index, possible_nav_group in enumerate(valid_top_groups):
             if top_group == possible_nav_group:
                 # all the nav groups past this point,
                 # 'c' is obscured by the web reader url, but valid for opds
                 tail_top_groups = valid_top_groups[possible_index:]
+                valid_nav_groups += tail_top_groups
 
-                self.valid_nav_groups = (*self.valid_nav_groups, *tail_top_groups)
-                if nav_group not in self.valid_nav_groups:
-                    route_changes = {"group": self.ROOT_GROUP}
+                if nav_group not in valid_nav_groups:
                     reason = (
                         f"Nav group {nav_group} unavailable, "
                         f"redirect to {self.ROOT_GROUP}"
                     )
-                    self._raise_redirect(route_changes, reason)
+                    self._raise_redirect(reason)
                 break
+        self.valid_nav_groups = tuple(valid_nav_groups)
 
-    def _raise_redirect(self, route_mask, reason, settings_mask=None):
-        """Redirect the client to a valid group url."""
-        route = deepcopy(dict(self.DEFAULT_ROUTE))
-        route["params"].update(route_mask)  # type: ignore
-        settings = deepcopy(self.params)
-        if settings_mask:
-            settings.update(settings_mask)
-        detail = {"route": route, "settings": settings, "reason": reason}
-        raise SeeOtherRedirectError(detail=detail)
-
-    def _validate_folder_settings(self, enable_folder_view):
+    def _validate_folder_settings(self):
         """Check that all the view variables for folder mode are set right."""
         # Check folder view admin flag
-        if not enable_folder_view:
+        if not self.admin_flags["folder_view"]:
             reason = "folder view disabled"
-            valid_top_groups = self._get_valid_top_groups()
+            valid_top_groups = self._get_valid_browse_top_groups()
             settings_mask = {"top_group": valid_top_groups[0]}
-            self._raise_redirect({}, reason, settings_mask)
-
-        top_group = self.params["top_group"]
-        if top_group != self.FOLDER_GROUP:
-            self.params["top_group"] = self.FOLDER_GROUP
+            self._raise_redirect(reason, settings_mask=settings_mask)
 
-        # set valid folder nav groups
-        self.valid_nav_groups = (self.FOLDER_GROUP,)
+        valid_top_groups = (self.FOLDER_GROUP,)
+        self._validate_top_group(valid_top_groups)
+        self.valid_nav_groups = valid_top_groups
 
     def _validate_browser_group_settings(self):
         """Check that all the view variables for browser mode are set right."""
-        nav_group = self.kwargs["group"]
-        top_group = self.params.get("top_group")
-        pk = self.kwargs["pk"]
-
         # Validate Browser top_group
         # Change top_group if its not in the valid top groups
-        valid_top_groups = self._get_valid_top_groups()
-        if top_group not in valid_top_groups:
-            reason = f"top_group {top_group} not in valid nav groups, changed to "
-            if nav_group in valid_top_groups:
-                valid_top_group = nav_group
-                reason += "nav group: "
-            else:
-                valid_top_group = valid_top_groups[0]
-                reason += "first valid top group "
-            reason += valid_top_group
-            LOG.debug(reason)
-            page = self.kwargs["page"]
-            route = {"group": nav_group, "pk": pk, "page": page}
-            settings_mask = {"top_group": valid_top_group}
-            self._raise_redirect(route, reason, settings_mask)
+        valid_top_groups = self._get_valid_browse_top_groups()
+        self._validate_top_group(valid_top_groups)
+
+        # Validate pks
+        nav_group = self.kwargs["group"]
+        pks = self.kwargs["pks"]
+        if nav_group == self.ROOT_GROUP and (pks and 0 not in pks):
+            # r never has pks
+            reason = f"Redirect r with {pks=} to pks 0"
+            self._raise_redirect(reason)
 
         # Validate Browser nav_group
         # Redirect if nav group is wrong
-        self._set_valid_browse_nav_groups(valid_top_groups)
-
-        # Validate pk
-        if nav_group == self.ROOT_GROUP and pk:
-            # r never has a pk
-            reason = f"Redirect r with {pk=} to pk 0"
-            self._raise_redirect({"pk": 0}, reason)
+        self.set_valid_browse_nav_groups(valid_top_groups)
 
     def _validate_story_arc_settings(self):
         """Validate story arc settings."""
-        top_group = self.params["top_group"]
-        if top_group != self.STORY_ARC_GROUP:
-            self.params["top_group"] = self.STORY_ARC_GROUP
-
-    def _set_route_param(self):
-        """Set the route param."""
-        group = self.kwargs.get("group", "r")
-        pk = self.kwargs.get("pk", 0)
-        page = self.kwargs.get("page", 1)
-        self.params["route"] = {"group": group, "pk": pk, "page": page}
-
-    def _set_admin_flags(self):
-        """Set browser relevant admin flags."""
-        admin_pairs = AdminFlag.objects.filter(
-            key__in=_ADMIN_FLAG_VALUE_KEY_MAP.keys()
-        ).values_list("key", "on")
-        admin_flags = {}
-        for key, on in admin_pairs:
-            export_key = _ADMIN_FLAG_VALUE_KEY_MAP[key]
-            admin_flags[export_key] = on
-        self.admin_flags = MappingProxyType(admin_flags)
+        valid_top_groups = (self.STORY_ARC_GROUP,)
+        self._validate_top_group(valid_top_groups)
+        self.valid_nav_groups = valid_top_groups
 
     def validate_settings(self):
         """Validate group and top group settings."""
-        group = self.kwargs.get("group")
-        self.set_order_key()
-        self._set_admin_flags()
-        enable_folder_view = self.admin_flags["folder_view"]
-
+        group = self.kwargs["group"]
         if group == self.FOLDER_GROUP:
-            self._validate_folder_settings(enable_folder_view)
+            self._validate_folder_settings()
         elif group == self.STORY_ARC_GROUP:
             self._validate_story_arc_settings()
         else:
             self._validate_browser_group_settings()
 
-        # Validate path sort
-        if self.order_key == "path" and not enable_folder_view:
-            pk = self.kwargs("pk")
-            page = self.kwargs("page")
-            route_changes = {"group": group, "pk": pk, "page": page}
-            reason = "order by path not allowed by admin flag."
+        # Validate order
+        if self.order_key == "filename" and not self.admin_flags["folder_view"]:
+            pks = self.kwargs["pks"]
+            page = self.kwargs["page"]
+            route_changes = {"group": group, "pks": pks, "page": page}
+            reason = "order by filename not allowed by admin flag."
             settings_mask = {"order_by": "sort_name"}
-            self._raise_redirect(route_changes, reason, settings_mask)
+            self._raise_redirect(reason, route_changes, settings_mask)
+
+    def init_request(self):
+        """Initialize request."""
+        super().init_request()
+        self._set_group_query_and_instance()
 
-    @extend_schema(request=BrowserAnnotationsView.input_serializer_class)
+    @extend_schema(request=BrowserBreadcrumbsView.input_serializer_class)
     def get(self, *_args, **_kwargs):
         """Get browser settings."""
-        self.parse_params()
-        self.validate_settings()
-        self._set_route_param()
+        self.init_request()
         data = self.get_object()
         serializer = self.get_serializer(data)
         self.save_params_to_session(self.params)