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

codex/views/browser/base.py

@@ -1,64 +1,38 @@
 """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
 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.util 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"})
-    TARGET = ""
 
     def __init__(self, *args, **kwargs):
         """Set params for the type checker."""
@@ -73,6 +47,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,65 +70,25 @@ 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
 
-    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(model)
-        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):
+    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 +99,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)

codex/views/browser/breadcrumbs.py

@@ -0,0 +1,202 @@
+"""Browser breadcrumbs calculations."""
+
+from contextlib import suppress
+from types import MappingProxyType
+
+from codex.logger.logging import get_logger
+from codex.views.browser.paginate import BrowserPaginateView
+from codex.views.const import FOLDER_GROUP, GROUP_NAME_MAP, GROUP_ORDER, STORY_ARC_GROUP
+from codex.views.util import Route
+
+LOG = get_logger(__name__)
+
+
+class BrowserBreadcrumbsView(BrowserPaginateView):
+    """Browser breadcrumbs calculations."""
+
+    def _init_breadcrumbs(self, valid_groups):
+        """Load breadcrumbs and determine if they should be searched for a graft."""
+        breadcrumbs: list[Route] = list(self.params.get("breadcrumbs", []))
+        old_breadcrumbs = [Route(**crumb) for crumb in breadcrumbs]
+        changed = bool(old_breadcrumbs) and old_breadcrumbs[-1].group in valid_groups
+        if changed:
+            old_breadcrumbs = []
+        return old_breadcrumbs, changed
+
+    def _breadcrumbs_save(self, breadcrumbs):
+        """Save the breadcrumbs to params."""
+        params = dict(self.params)
+        params["breadcrumbs"] = tuple(crumb.dict() for crumb in breadcrumbs)
+        self.params = MappingProxyType(params)
+
+    def _breadcrumbs_graft_or_create_story_arc(self) -> tuple[tuple[Route, ...], bool]:
+        """Graft or create story_arc breadcrumbs."""
+        old_breadcrumbs, changed = self._init_breadcrumbs(STORY_ARC_GROUP)
+
+        pks = self.kwargs["pks"]
+        page = self.kwargs["page"]
+        gi = self.group_instance  # type: ignore
+        name = gi.name if gi else ""
+        group_crumb = Route(STORY_ARC_GROUP, pks, page, name)
+
+        if old_breadcrumbs and old_breadcrumbs[-1] & group_crumb:
+            # Graft. Hurray
+            breadcrumbs = old_breadcrumbs
+        else:
+            # Create
+            new_breadcrumbs = [group_crumb]
+            if group_crumb.pks and 0 not in group_crumb.pks:
+                # Add head.
+                new_breadcrumbs = [Route(STORY_ARC_GROUP, ()), *new_breadcrumbs]
+            changed = True
+            breadcrumbs = new_breadcrumbs
+
+        return tuple(breadcrumbs), changed
+
+    @staticmethod
+    def _breadcrumb_find_branch(reverse_breadcrumbs, crumb) -> list[Route] | None:
+        """Find a graftable breadcrumb branch."""
+        for index, breadcrumb in enumerate(reverse_breadcrumbs):
+            if breadcrumb & crumb:
+                return list(reversed(reverse_breadcrumbs[index:]))
+        return None
+
+    def _breadcrumbs_graft_or_create_folder(self) -> tuple[tuple[Route, ...], bool]:
+        """Graft or create folder breadcrumbs."""
+        old_breadcrumbs, changed = self._init_breadcrumbs(FOLDER_GROUP)
+
+        reversed_breadcrumbs = list(reversed(old_breadcrumbs))
+
+        pks = self.kwargs["pks"]
+        page = self.kwargs["page"]
+        folder = self.group_instance  # type: ignore
+        name = folder.name if folder and pks else ""
+        group_crumb = Route(FOLDER_GROUP, pks, page, name)
+        new_breadcrumbs = []
+
+        while True:
+            branch = self._breadcrumb_find_branch(reversed_breadcrumbs, group_crumb)
+            if branch and not branch[0].pks:
+                # Branch must have the top as a head.
+                # Graft. Hurray.
+                new_breadcrumbs = branch + new_breadcrumbs
+                break
+
+            # Add head
+            new_breadcrumbs = [group_crumb, *new_breadcrumbs]
+            changed = True
+            if not group_crumb.pks:
+                break
+
+            # parent next
+            if not folder:
+                break
+            folder = folder.parent_folder
+            if folder:
+                group_crumb = Route(FOLDER_GROUP, (folder.pk,), 1, name=folder.name)
+            else:
+                group_crumb = Route(FOLDER_GROUP, (), 1, name="")
+
+        breadcrumbs = new_breadcrumbs
+
+        return tuple(breadcrumbs), changed
+
+    def _get_breadcrumbs_group_crumb(self, group):
+        """Create the crumb for this group."""
+        gi = self.group_instance  # type: ignore
+        if not gi:
+            pks = ()
+            page = 1
+            name = ""
+        if group == self.kwargs["group"]:
+            # create self crumb
+            pks = self.kwargs["pks"]
+            page = self.kwargs["page"]
+            name = gi.name if gi else ""
+        else:
+            page = 1
+            if (attr := GROUP_NAME_MAP.get(group)) and (
+                parent_group := getattr(gi, attr, None)
+            ):
+                pks = (parent_group.pk,)
+                name = parent_group.name
+            else:
+                pks = ()
+                name = ""
+
+        return Route(group, pks, page, name)
+
+    def _breadcrumbs_graft_or_create_group_crumb(
+        self, group, old_breadcrumbs, new_breadcrumbs, changed
+    ) -> tuple[bool, bool]:
+        """Graft or create one browse group breadcrumb."""
+        group_crumb = self._get_breadcrumbs_group_crumb(group)
+
+        if old_breadcrumbs and (
+            (group_crumb == old_breadcrumbs[-1])
+            or (changed and (group_crumb & old_breadcrumbs[-1]))
+            and not old_breadcrumbs[0].pks
+        ):
+            # Graft. Hurray
+            new_breadcrumbs[0:0] = old_breadcrumbs
+            done = True
+        else:
+            # Insert the new node
+            new_breadcrumbs.insert(0, group_crumb)
+            changed = True
+            done = False
+        return done, changed
+
+    def _breadcrumbs_graft_or_create_group(self) -> tuple[tuple[Route, ...], bool]:
+        """Graft or create browse group breadcrumbs."""
+        old_breadcrumbs, changed = self._init_breadcrumbs(GROUP_ORDER)
+
+        vng = self.valid_nav_groups  # type: ignore
+        test_groups = tuple(reversed(vng[:-1]))
+        new_breadcrumbs = []
+        level = done = False
+        try:
+            browser_group_index = GROUP_ORDER.index(self.kwargs["group"])
+        except ValueError:
+            browser_group_index = -1
+
+        for group in test_groups:
+            try:
+                with suppress(ValueError):
+                    level = level or GROUP_ORDER.index(group) <= browser_group_index
+                if level:
+                    done, changed = self._breadcrumbs_graft_or_create_group_crumb(
+                        group, old_breadcrumbs, new_breadcrumbs, changed
+                    )
+                try:
+                    if old_breadcrumbs and GROUP_ORDER.index(
+                        old_breadcrumbs[-1].group
+                    ) >= GROUP_ORDER.index(group):
+                        # Trim old_breadcrumbs to match to group
+                        old_breadcrumbs.pop(-1)
+                except ValueError:
+                    old_breadcrumbs = []
+
+                if done:
+                    break
+            except Exception:
+                LOG.exception("group loop")
+
+        return tuple(new_breadcrumbs), changed
+
+    def get_parent_breadcrumbs(
+        self,
+    ) -> tuple[Route, ...]:
+        """Graft or create breadcrumbs by browser mode."""
+        group = self.kwargs["group"]
+        if group == FOLDER_GROUP:
+            breadcrumbs, changed = self._breadcrumbs_graft_or_create_folder()
+        elif group == STORY_ARC_GROUP:
+            breadcrumbs, changed = self._breadcrumbs_graft_or_create_story_arc()
+        else:
+            breadcrumbs, changed = self._breadcrumbs_graft_or_create_group()
+
+        if changed:
+            self._breadcrumbs_save(breadcrumbs)
+
+        return breadcrumbs[:-1] if breadcrumbs else ()