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

codex/views/browser/paginate.py

@@ -0,0 +1,106 @@
+"""Browser pagination."""
+
+from math import ceil
+
+from django.core.paginator import EmptyPage, Paginator
+
+from codex.logger.logging import get_logger
+from codex.models import (
+    Comic,
+    Folder,
+)
+from codex.views.browser.annotations import BrowserAnnotationsView
+from codex.views.const import (
+    MAX_OBJ_PER_PAGE,
+)
+
+LOG = get_logger(__name__)
+
+
+class BrowserPaginateView(BrowserAnnotationsView):
+    """Browser pagination."""
+
+    def _check_page_in_bounds(self, total_count):
+        """Redirect page out of bounds."""
+        pks = self.kwargs.get("pks")
+        page = self.kwargs.get("page", 1)
+        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
+
+        # 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 for the group.
+            pks = "0"
+            new_page = 1
+
+        reason = f"{page=} does not exist!"
+        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."""
+        orphans = 0 if self.model_group == "f" or self.params.get("q") else 5
+        paginator = Paginator(qs, MAX_OBJ_PER_PAGE, orphans=orphans)
+        try:
+            qs = paginator.page(page).object_list
+        except EmptyPage:
+            if model != Folder:
+                model_name = self.model.__name__ if self.model else "NO_MODEL"
+                LOG.warning(f"No {model_name}s on page {page}")
+            qs = model.objects.none()
+
+        return qs
+
+    def _paginate_groups(self, group_qs, total_group_count):
+        """Paginate the group object list before books."""
+        if total_group_count:
+            page = self.kwargs.get("page", 1)
+            page_group_qs = self._paginate_section(self.model, group_qs, page)
+        else:
+            page_group_qs = self.model.objects.none()  # type: ignore
+        return page_group_qs
+
+    def _paginate_books(self, book_qs, total_group_count, page_obj_count):
+        """Paginate the book object list based on how many group/folders are showing."""
+        if page_obj_count >= MAX_OBJ_PER_PAGE:
+            # No books for this page
+            page_book_qs = Comic.objects.none()
+        else:
+            group_remainder = total_group_count % MAX_OBJ_PER_PAGE
+            if page_obj_count:
+                # There are books after the groups on the same page
+                # Manually add books without the paginator
+                book_limit = MAX_OBJ_PER_PAGE - group_remainder
+                page_book_qs = book_qs[:book_limit]
+            else:
+                # There are books after the groups on a new page
+                if group_remainder:
+                    book_offset = MAX_OBJ_PER_PAGE - group_remainder
+                    page_book_qs = book_qs[book_offset:]
+                else:
+                    page_book_qs = book_qs
+
+                num_group_and_mixed_pages = ceil(total_group_count / MAX_OBJ_PER_PAGE)
+                book_only_page = self.kwargs.get("page", 1) - num_group_and_mixed_pages
+                page_book_qs = self._paginate_section(
+                    Comic, page_book_qs, book_only_page
+                )
+        return page_book_qs
+
+    def paginate(self, group_qs, book_qs, group_count, book_count):
+        """Paginate the queryset into a group and book object lists."""
+        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()
+
+        return page_group_qs, page_book_qs, num_pages, page_group_count, page_book_count

codex/views/browser/settings.py

@@ -0,0 +1,66 @@
+"""Browser session view."""
+
+from codex.serializers.browser.settings import BrowserSettingsSerializer
+from codex.views.const import GROUP_ORDER
+from codex.views.settings import SettingsView
+
+
+class BrowserSettingsView(SettingsView):
+    """Get Browser Settings."""
+
+    # Put Browser Settings is normally done through BrowserView.get()
+    serializer_class = BrowserSettingsSerializer  # type: ignore
+
+    SESSION_KEY = SettingsView.BROWSER_SESSION_KEY
+
+    @staticmethod
+    def _strip_breadcrumb_names(params):
+        """Remove names from breadcrumbs."""
+        breadcrumbs = params.get("breadcrumbs")
+        if not breadcrumbs:
+            return params
+        nameless_breadcrumbs = []
+        for crumb in breadcrumbs:
+            crumb.pop("name", None)
+            nameless_breadcrumbs.append(crumb)
+        params["breadcrumbs"] = nameless_breadcrumbs
+        return params
+
+    @staticmethod
+    def _validate_browse_top_group(params, group, top_group):
+        """Validate top group for browse groups."""
+        show = params["show"]
+        if group == "r" or (
+            show.get(top_group)
+            and GROUP_ORDER.index(top_group) < GROUP_ORDER.index(group)
+        ):
+            return
+
+        for show_group, on in show.items():
+            if on:
+                params["top_group"] = show_group
+                break
+        else:
+            params["top_group"] = "c"
+
+    @classmethod
+    def _validate_top_group(cls, params, group, top_group):
+        """Validate top group."""
+        if group == top_group:
+            return
+
+        if group in ("f", "a"):
+            params["top_group"] = group
+        else:
+            cls._validate_browse_top_group(params, group, top_group)
+
+    def validate_settings_get(self, validated_data, params):
+        """Change bad settings."""
+        top_group = params["top_group"]
+        group = validated_data.get("group", "r") if validated_data else "r"
+        self._validate_top_group(params, group, top_group)
+
+        if not validated_data.get("breadcrumb_names", True):
+            params = self._strip_breadcrumb_names(params)
+
+        return params

codex/views/browser/title.py

@@ -0,0 +1,48 @@
+"""Browser title."""
+
+from codex.models import BrowserGroupModel, Comic, Volume
+from codex.views.browser.breadcrumbs import BrowserBreadcrumbsView
+
+
+class BrowserTitleView(BrowserBreadcrumbsView):
+    """Browser title methods."""
+
+    def __init__(self, *args, **kwargs):
+        """Set params for the type checker."""
+        super().__init__(*args, **kwargs)
+        self.group_instance: BrowserGroupModel | None = None
+
+    def _get_root_group_name(self):
+        if not self.model:
+            reason = "No model set in browser"
+            raise ValueError(reason)
+        plural = self.model._meta.verbose_name_plural
+        if not plural:
+            reason = f"No plural name for {self.model}"
+            raise ValueError(reason)
+        return plural.capitalize(), 0
+
+    def _get_group_name(self):
+        group_count = 0
+        if gi := self.group_instance:
+            if isinstance(gi, Volume):
+                group_count = gi.series.volume_count
+            elif isinstance(gi, Comic):
+                group_count = gi.volume.issue_count
+            group_name = gi.name
+        else:
+            group_name = ""
+        return group_name, group_count
+
+    def get_browser_page_title(self):
+        """Get the proper title for this browse level."""
+        pks = self.kwargs.get("pks")
+        if not pks:
+            group_name, group_count = self._get_root_group_name()
+        else:
+            group_name, group_count = self._get_group_name()
+
+        return {
+            "group_name": group_name,
+            "group_count": group_count,
+        }

codex/views/browser/validate.py

@@ -0,0 +1,161 @@
+"""Browser Settings and URL Validation."""
+
+from copy import deepcopy
+from types import MappingProxyType
+
+from codex.exceptions import SeeOtherRedirectError
+from codex.logger.logging import get_logger
+from codex.serializers.choices import DEFAULTS
+from codex.views.browser.base import BrowserBaseView
+from codex.views.const import (
+    COMIC_GROUP,
+    FOLDER_GROUP,
+    ROOT_GROUP,
+    STORY_ARC_GROUP,
+)
+
+LOG = get_logger(__name__)
+_NO_TOP_GROUP_VALIDATE = frozenset({"metadata"})
+
+
+class BrowserValidateView(BrowserBaseView):
+    """Browser Settings and URL Validation."""
+
+    DEFAULT_ROUTE = MappingProxyType(
+        {
+            "name": "browser",
+            "params": deepcopy(DEFAULTS["breadcrumbs"][0]),
+        }
+    )
+
+    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)
+
+    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 = 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 += [COMIC_GROUP]
+
+        return valid_top_groups
+
+    def _validate_top_group(self, valid_top_groups):
+        # if self.TARGET in _NO_TOP_GROUP_VALIDATE:
+        #    return
+        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
+        enabled in browser settings.
+
+        May always navigate to root 'r' nav group.
+        """
+        top_group = self.params["top_group"]
+        nav_group = self.kwargs["group"]
+        valid_nav_groups = [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
+
+                if nav_group not in valid_nav_groups:
+                    reason = (
+                        f"Nav group {nav_group} unavailable, "
+                        f"redirect to {ROOT_GROUP}"
+                    )
+                    self.raise_redirect(reason)
+                break
+        self.valid_nav_groups = tuple(valid_nav_groups)
+
+    def _validate_folder_settings(self):
+        """Check that all the view variables for folder mode are set right."""
+        # Check folder view admin flag
+        if not self.admin_flags["folder_view"]:
+            reason = "folder view disabled"
+            valid_top_groups = self._get_valid_browse_top_groups()
+            settings_mask = {"top_group": valid_top_groups[0]}
+            self.raise_redirect(reason, settings_mask=settings_mask)
+
+        valid_top_groups = (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."""
+        # Validate Browser top_group
+        # Change top_group if its not in the valid top groups
+        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 == 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)
+
+    def _validate_story_arc_settings(self):
+        """Validate story arc settings."""
+        valid_top_groups = (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["group"]
+        if group == FOLDER_GROUP:
+            self._validate_folder_settings()
+        elif group == STORY_ARC_GROUP:
+            self._validate_story_arc_settings()
+        else:
+            self._validate_browser_group_settings()
+
+        # 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(reason, route_changes, settings_mask)

codex/views/const.py

@@ -1,3 +1,160 @@
 """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,
+    BrowserGroupModel,
+    Character,
+    Comic,
+    Contributor,
+    ContributorPerson,
+    ContributorRole,
+    Country,
+    Folder,
+    Genre,
+    Identifier,
+    IdentifierType,
+    Imprint,
+    Language,
+    Library,
+    Location,
+    OriginalFormat,
+    Publisher,
+    ScanInfo,
+    Series,
+    SeriesGroup,
+    StoryArc,
+    StoryArcNumber,
+    Tag,
+    Tagger,
+    Team,
+    Volume,
+)
+from codex.settings.settings import CODEX_PATH
+
 FALSY = {None, "", "false", "0", False}
+GROUP_NAME_MAP = MappingProxyType(
+    {"p": "publisher", "i": "imprint", "s": "series", "v": "volume"}
+)
+STATIC_IMG_PATH = CODEX_PATH / "static_root/img"
+MISSING_COVER_NAME_MAP = MappingProxyType(
+    {
+        **GROUP_NAME_MAP,
+        "f": "folder",
+        "a": "story-arc",
+    }
+)
+MISSING_COVER_FN = "missing-cover-165.webp"
+MISSING_COVER_PATH = STATIC_IMG_PATH / MISSING_COVER_FN
+
+
+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",
+    }
+)
+FILTER_ONLY_GROUP_RELATION = MappingProxyType(
+    {
+        **GROUP_NAME_MAP,
+        FOLDER_GROUP: "folders",
+        STORY_ARC_GROUP: "story_arc_numbers__story_arc",
+    }
+)
+METADATA_GROUP_RELATION = MappingProxyType(
+    {
+        **GROUP_NAME_MAP,
+        COMIC_GROUP: "pk",
+        # Possible to list all groups in a non group view, but could get crazy.
+        # FOLDER_GROUP: "comic__folder",
+        # STORY_ARC_GROUP: "comic__story_arc_number__story_arc"
+    }
+)
+CUSTOM_COVER_GROUP_RELATION = MappingProxyType(
+    {**GROUP_NAME_MAP, FOLDER_GROUP: "folder", STORY_ARC_GROUP: "storyarc"}
+)
+GROUP_ORDER = "rpisv"
+MODEL_REL_MAP = MappingProxyType(
+    {
+        Publisher: "publisher",
+        Imprint: "imprint",
+        Series: "series",
+        Volume: "volume",
+        Folder: "parent_folder",
+        StoryArc: "story_arc_numbers__story_arc",
+        Comic: "pk",
+    }
+)
+GROUP_MODEL_MAP: MappingProxyType[str, type[BrowserGroupModel] | None] = (
+    MappingProxyType(
+        {
+            ROOT_GROUP: None,
+            "p": Publisher,
+            "i": Imprint,
+            "s": Series,
+            "v": Volume,
+            COMIC_GROUP: Comic,
+            FOLDER_GROUP: Folder,
+            STORY_ARC_GROUP: StoryArc,
+        }
+    )
+)
+GROUP_MODELS = (
+    Publisher,
+    Imprint,
+    Series,
+    Volume,
+    Folder,
+    StoryArc,
+)
+STATS_GROUP_MODELS = (
+    *GROUP_MODELS,
+    Comic,
+)
+METADATA_MODELS = (
+    AgeRating,
+    Character,
+    Country,
+    Genre,
+    Identifier,
+    IdentifierType,
+    Language,
+    Location,
+    OriginalFormat,
+    SeriesGroup,
+    ScanInfo,
+    StoryArc,
+    StoryArcNumber,
+    Team,
+    Tag,
+    Tagger,
+    Contributor,
+    ContributorPerson,
+    ContributorRole,
+)
+CONFIG_MODELS = (
+    Library,
+    User,
+    Group,
+    Session,
+)
+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_DATETIMEFIELD = Value(EPOCH_START)

codex/views/download.py

@@ -1,33 +1,21 @@
 """Download a comic archive."""
 
 from pathlib import Path
-from typing import ClassVar
 
 from django.http import FileResponse, Http404
 from drf_spectacular.types import OpenApiTypes
 from drf_spectacular.utils import extend_schema
-from rest_framework.views import APIView
 
 from codex.models import Comic
-from codex.views.auth import GroupACLMixin, IsAuthenticatedOrEnabledNonUsers
+from codex.views.auth import AuthFilterAPIView
 
 
-class DownloadView(APIView, GroupACLMixin):
+class DownloadView(AuthFilterAPIView):
     """Return the comic archive file as an attachment."""
 
-    permission_classes: ClassVar[list] = [IsAuthenticatedOrEnabledNonUsers]  # type: ignore
     content_type = "application/vnd.comicbook+zip"
 
-    _DOWNLOAD_SELECT_RELATED = ("series", "volume")
-    _DOWNLOAD_FIELDS = (
-        "path",
-        "series",
-        "volume",
-        "issue_number",
-        "issue_suffix",
-        "name",
-    )
-    AS_ATTACHMENT = True
+    _AS_ATTACHMENT = True
 
     @extend_schema(responses={(200, content_type): OpenApiTypes.BINARY})
     def get(self, *_args, **kwargs):
@@ -37,8 +25,7 @@ class DownloadView(APIView, GroupACLMixin):
             group_acl_filter = self.get_group_acl_filter(Comic)
             comic = (
                 Comic.objects.filter(group_acl_filter)
-                .select_related(*self._DOWNLOAD_SELECT_RELATED)
-                .only(*self._DOWNLOAD_FIELDS)
+                .only("path", "file_type")
                 .get(pk=pk)
             )
         except Comic.DoesNotExist as err:
@@ -55,15 +42,16 @@ class DownloadView(APIView, GroupACLMixin):
         else:
             content_type += "octet-stream"
 
+        filename = comic.get_filename()
         return FileResponse(
             comic_file,
-            as_attachment=self.AS_ATTACHMENT,
+            as_attachment=self._AS_ATTACHMENT,
             content_type=content_type,
-            filename=comic.filename(),
+            filename=filename,
         )
 
 
 class FileView(DownloadView):
     """View a comic in the browser."""
 
-    AS_ATTACHMENT = False
+    _AS_ATTACHMENT = False

codex/views/error.py

@@ -22,8 +22,8 @@ def codex_exception_handler(exc, context):
             status.HTTP_400_BAD_REQUEST,
             status.HTTP_404_NOT_FOUND,
         ):
-            opds_start = reverse(name)
-            response = redirect(opds_start, permanent=False)
+            url = reverse(name)
+            response = redirect(url, permanent=False)
 
     if not response:
         response = exception_handler(exc, context)

codex/views/frontend.py

@@ -5,17 +5,22 @@ from typing import ClassVar
 from rest_framework.renderers import TemplateHTMLRenderer
 from rest_framework.response import Response
 
-from codex.views.session import BrowserSessionViewBase
+from codex.serializers.route import RouteSerializer
+from codex.views.session import SessionView
 
 
-class IndexView(BrowserSessionViewBase):
+class IndexView(SessionView):
     """The main app."""
 
+    SESSION_KEY = SessionView.BROWSER_SESSION_KEY
+
     renderer_classes: ClassVar[list] = [TemplateHTMLRenderer]  # type: ignore
     template_name = "index.html"
 
     def get(self, *_args, **_kwargs):
         """Get the app index page."""
-        last_route = self.get_from_session("route")
+        last_route = self.get_last_route(name=False)
+        serializer = RouteSerializer(last_route)
+        last_route = serializer.data
         extra_context = {"last_route": last_route}
         return Response(extra_context)