codex 1.6.0a6__py3-none-any.whl → 1.6.0a8__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/{session.py → settings.py}

@@ -1,12 +1,13 @@
 """Browser session view."""
 
 from codex.serializers.browser.settings import BrowserSettingsSerializer
-from codex.views.session import BrowserSessionViewBase, SessionViewBase
+from codex.views.settings import SettingsView
 
 
-class BrowserSessionView(BrowserSessionViewBase, SessionViewBase):
+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

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,158 @@
+"""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__)
+
+
+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):
+        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

@@ -2,6 +2,38 @@
 
 from types import MappingProxyType
 
+from django.contrib.auth.models import Group, User
+from django.contrib.sessions.models import Session
+
+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}
@@ -18,3 +50,80 @@ MISSING_COVER_NAME_MAP = MappingProxyType(
 )
 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",
+    }
+)
+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,
+    Comic,
+    Folder,
+)
+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})

codex/views/download.py

@@ -1,24 +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"
 
-    AS_ATTACHMENT = True
+    _AS_ATTACHMENT = True
 
     @extend_schema(responses={(200, content_type): OpenApiTypes.BINARY})
     def get(self, *_args, **kwargs):
@@ -48,7 +45,7 @@ class DownloadView(APIView, GroupACLMixin):
         filename = comic.get_filename()
         return FileResponse(
             comic_file,
-            as_attachment=self.AS_ATTACHMENT,
+            as_attachment=self._AS_ATTACHMENT,
             content_type=content_type,
             filename=filename,
         )
@@ -57,4 +54,4 @@ class DownloadView(APIView, GroupACLMixin):
 class FileView(DownloadView):
     """View a comic in the browser."""
 
-    AS_ATTACHMENT = False
+    _AS_ATTACHMENT = False

codex/views/frontend.py

@@ -6,12 +6,14 @@ from rest_framework.renderers import TemplateHTMLRenderer
 from rest_framework.response import Response
 
 from codex.serializers.route import RouteSerializer
-from codex.views.session import BrowserSessionViewBase
+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"
 

codex/views/mtime.py

@@ -0,0 +1,72 @@
+"""Get the mtimes for the submitted groups."""
+
+from django.db.models import Max
+from rest_framework.response import Response
+
+from codex.models.groups import Publisher
+from codex.serializers.mtime import GroupsMtimeSerializer, MtimeSerializer
+from codex.util import max_none
+from codex.views.auth import AuthGenericAPIView
+from codex.views.browser.filters.bookmark import BookmarkFilterMixin
+from codex.views.const import GROUP_MODEL_MAP
+from codex.views.util import reparse_json_query_params
+
+_REPARSE_JSON_FIELDS = frozenset({"groups"})
+
+
+class MtimeView(AuthGenericAPIView, BookmarkFilterMixin):
+    """Get the mtimes for the submitted groups."""
+
+    serializer_class = GroupsMtimeSerializer
+    response_serializer_class = MtimeSerializer
+
+    def _parse_params(self):
+        params = reparse_json_query_params(self.request.GET, _REPARSE_JSON_FIELDS)
+        self.groups = params.get("groups", "")
+        self.use_bookmark_filter = self.request.GET.get("use_bookmark_filter", False)
+
+    def _get_group_mtime(self, group, pks):
+        """Get one group's mtimes."""
+        model = GROUP_MODEL_MAP[group]
+        if not model:
+            model = Publisher
+
+        qs = model.objects.all()
+
+        if pks and 0 not in pks:
+            qs = qs.filter(pk__in=pks)
+        updated_at_max = qs.aggregate(max=Max("updated_at"))["max"]
+
+        if self.use_bookmark_filter:
+            bm_rel = self.get_bm_rel(model)
+            bm_filter = self.get_my_bookmark_filter(bm_rel)
+            qs = qs.filter(bm_filter)
+            bookmark_updated_at_max = qs.aggregate(max=(Max(f"{bm_rel}__updated_at")))[
+                "max"
+            ]
+            updated_at_max = max_none(updated_at_max, bookmark_updated_at_max)
+
+        return updated_at_max
+
+    def get_max_groups_mtime(self):
+        """Get max mtime for all groups."""
+        max_mtime = None
+
+        for item in self.groups:
+            group = item["group"]
+            pks = tuple(int(pk) for pk in item["pks"].split(","))
+            mtime = self._get_group_mtime(group, pks)
+            max_mtime = max_none(max_mtime, mtime)
+        return max_mtime
+
+    def get(self, *args, **kwargs):
+        """Get the mtimes for the submitted groups."""
+        # Parse Request
+        self._parse_params()
+
+        max_mtime = self.get_max_groups_mtime()
+
+        # Serialize Response
+        result = {"max_mtime": max_mtime}
+        serializer = self.response_serializer_class(result)
+        return Response(serializer.data)

codex/views/opds/auth.py

@@ -0,0 +1,17 @@
+"""OPDS Authentican mixin."""
+
+from rest_framework.authentication import BasicAuthentication, SessionAuthentication
+
+from codex.views.auth import IsAuthenticatedOrEnabledNonUsers
+from codex.views.template import CodexXMLTemplateView
+
+
+class OPDSAuthMixin:
+    """Add Basic Auth."""
+
+    authentication_classes = (SessionAuthentication, BasicAuthentication)
+    permission_classes = (IsAuthenticatedOrEnabledNonUsers,)
+
+
+class OPDSTemplateView(OPDSAuthMixin, CodexXMLTemplateView):
+    """XML Template view with OPDSAuth."""