codex 1.4.0a1__py3-none-any.whl → 1.4.1__py3-none-any.whl

codex/views/opds/util.py

@@ -1,5 +1,7 @@
 """OPDS Utility classes."""
 from django.db.models import F
+from django.http.response import HttpResponseRedirect
+from django.urls import reverse
 from django.utils.http import urlencode
 
 from codex.models import (
@@ -13,6 +15,7 @@ from codex.models import (
     Tag,
     Team,
 )
+from codex.serializers.choices import DEFAULTS
 
 OPDS_M2M_MODELS = (Character, Genre, Location, SeriesGroup, StoryArc, Tag, Team)
 
@@ -61,6 +64,39 @@ def get_m2m_objects(pk) -> dict:
     cats = {}
     for model in OPDS_M2M_MODELS:
         table = model.__name__.lower()
-        qs = model.objects.filter(comic=pk).order_by("name").only("name")
+        rel = "comic"
+        if model == StoryArc:
+            rel = "storyarcnumber__" + rel
+        comic_filter = {rel: pk}
+        qs = model.objects.filter(**comic_filter).order_by("name").only("name")
         cats[table] = qs
+
     return cats
+
+
+def full_redirect_view(url_name):
+    """Redirect to view, for a url name."""
+
+    def func(request):
+        """Redirect to view, forwarding query strings and auth."""
+        kwargs = DEFAULTS["route"]
+        url = reverse(url_name, kwargs=kwargs)
+
+        # Forward the query string.
+        path = request.get_full_path()
+        if path:
+            parts = path.split("?")
+            if len(parts) >= 2:  # noqa PLR2004
+                parts[0] = url
+                url = "?".join(parts)
+
+        response = HttpResponseRedirect(url)
+
+        # Forward authorization.
+        auth_header = request.META.get("HTTP_AUTHORIZATION")
+        if auth_header:
+            response["HTTP_AUTHORIZATION"] = auth_header
+
+        return response
+
+    return func

codex/views/opds/v1/__init__.py

@@ -1 +1 @@
-"""OPDS 1 Views."""
+"""OPDS v1 Views."""

codex/views/opds/v1/data.py

@@ -0,0 +1,21 @@
+"""OPDS v1 Data classes."""
+from dataclasses import dataclass
+from datetime import datetime
+from typing import Optional
+
+
+@dataclass
+class OPDS1Link:
+    """An OPDS Link."""
+
+    rel: str
+    href: str
+    mime_type: str
+    title: str = ""
+    length: int = 0
+    facet_group: str = ""
+    facet_active: bool = False
+    thr_count: int = 0
+    pse_count: int = 0
+    pse_last_read: int = 0
+    pse_last_read_date: Optional[datetime] = None

codex/views/opds/v1/entry/__init__.py

@@ -0,0 +1 @@
+"""OPDS v1 Entries."""

codex/views/opds/v1/entry/data.py

@@ -0,0 +1,23 @@
+"""OPDS v1 Entry Data classes."""
+from dataclasses import dataclass
+
+
+@dataclass
+class OPDS1EntryObject:
+    """Fake entry db object for top link & facet entries."""
+
+    group: str = ""
+    pk: int = 0
+    name: str = ""
+    summary: str = ""
+    fake: bool = True
+
+
+@dataclass
+class OPDS1EntryData:
+    """Entry Data class to avoid to many args."""
+
+    acquisition_groups: frozenset
+    issue_max: int
+    metadata: bool
+    mime_type_map: dict

codex/views/opds/v1/entry/entry.py

@@ -0,0 +1,151 @@
+"""OPDS v1 Entry."""
+import json
+from datetime import datetime, timezone
+from urllib.parse import urlencode
+
+from django.urls import reverse
+
+from codex.logger.logging import get_logger
+from codex.models import Comic
+from codex.views.opds.const import (
+    AUTHOR_ROLES,
+    BLANK_TITLE,
+)
+from codex.views.opds.util import (
+    get_creator_people,
+    get_m2m_objects,
+)
+from codex.views.opds.v1.entry.links import OPDS1EntryLinksMixin
+
+LOG = get_logger(__name__)
+
+
+class OPDS1Entry(OPDS1EntryLinksMixin):
+    """An OPDS entry object."""
+
+    _DATE_FORMAT_BASE = "%Y-%m-%dT%H:%M:%S"
+    _DATE_FORMAT_MS = _DATE_FORMAT_BASE + ".%f%z"
+    _DATE_FORMAT = _DATE_FORMAT_BASE + "%z"
+    _DATE_FORMATS = (_DATE_FORMAT_MS, _DATE_FORMAT)
+
+    @property
+    def id_tag(self):
+        """GUID is a nav url."""
+        # Id top links by query params but not regular entries.
+        return self._nav_href(metadata=self.metadata)
+
+    @property
+    def title(self):
+        """Compute the item title."""
+        result = ""
+        try:
+            parts = []
+            if not self.fake:
+                group = self.obj.group
+                if group == "i":
+                    parts.append(self.obj.publisher_name)
+                elif group == "v":
+                    parts.append(self.obj.series_name)
+                elif group == "c":
+                    title = Comic.get_title(self.obj, issue_max=self.issue_max)
+                    parts.append(title)
+
+            if name := self.obj.name:
+                parts.append(name)
+
+            result = " ".join(filter(None, parts))
+        except Exception as exc:
+            LOG.exception(exc)
+
+        if not result:
+            result = BLANK_TITLE
+        return result
+
+    @property
+    def issued(self):
+        """Return the published date."""
+        if self.obj.group == "c":
+            return self.obj.date
+        return None
+
+    @property
+    def publisher(self):
+        """Return the publisher."""
+        return self.obj.publisher_name
+
+    def _get_datefield(self, key):
+        result = None
+        if not self.fake and (value := getattr(self.obj, key, None)):
+            for date_format in self._DATE_FORMATS:
+                try:
+                    if isinstance(value, str):
+                        result = datetime.strptime(value, date_format).astimezone(
+                            timezone.utc
+                        )
+                    if isinstance(value, datetime):
+                        result = value.astimezone(timezone.utc).strftime(date_format)
+                    break
+                except ValueError:
+                    pass
+        return result
+
+    @property
+    def updated(self):
+        """When the entry was last updated."""
+        return self._get_datefield("updated_at")
+
+    @property
+    def published(self):
+        """When the entry was created."""
+        return self._get_datefield("created_at")
+
+    @property
+    def language(self):
+        """Return the entry language."""
+        return self.obj.language
+
+    @property
+    def summary(self):
+        """Return a child count or comic summary."""
+        if self.obj.group == "c":
+            desc = self.obj.summary
+        else:
+            children = self.obj.child_count
+            desc = f"{children} issues"
+        return desc
+
+    @staticmethod
+    def _add_url_to_obj(objs, filter_key):
+        """Add filter urls to objects."""
+        kwargs = {"group": "s", "pk": 0, "page": 1}
+        url_base = reverse("opds:v1:feed", kwargs=kwargs)
+        result = []
+        for obj in objs:
+            qp = {"filters": json.dumps({filter_key: [obj.pk]})}
+            qp = urlencode(qp)
+            obj.url = url_base + "?" + qp
+            result.append(obj)
+        return result
+
+    @property
+    def authors(self):
+        """Get Author names."""
+        if not self.metadata:
+            return []
+        people = get_creator_people(self.obj.pk, AUTHOR_ROLES)
+        return self._add_url_to_obj(people, "creators")
+
+    @property
+    def contributors(self):
+        """Get Contributor names."""
+        if not self.metadata:
+            return []
+        people = get_creator_people(self.obj.pk, AUTHOR_ROLES, exclude=True)
+        return self._add_url_to_obj(people, "creators")
+
+    @property
+    def category_groups(self):
+        """Get Category labels."""
+        if not self.metadata:
+            return {}
+        return get_m2m_objects(self.obj.pk)

codex/views/opds/v1/entry/links.py

@@ -0,0 +1,135 @@
+"""OPDS v1 Entry Links Methods."""
+from urllib.parse import quote_plus
+
+from django.contrib.staticfiles.storage import staticfiles_storage
+from django.urls import reverse
+
+from codex.models import Comic
+from codex.views.opds.const import MimeType, Rel
+from codex.views.opds.util import update_href_query_params
+from codex.views.opds.v1.data import OPDS1Link
+from codex.views.opds.v1.entry.data import OPDS1EntryData, OPDS1EntryObject
+
+
+class OPDS1EntryLinksMixin:
+    """OPDS v1 Entry Links Methods."""
+
+    def __init__(self, obj, query_params, data: OPDS1EntryData):
+        """Initialize params."""
+        self.obj = obj
+        self.fake = isinstance(self.obj, OPDS1EntryObject)
+        self.query_params = query_params
+        self.acquision_groups = data.acquisition_groups
+        self.issue_max = data.issue_max
+        self.metadata = data.metadata
+        self.mime_type_map = data.mime_type_map
+
+    def _thumb_link(self):
+        if self.fake:
+            return None
+        cover_pk = self.obj.cover_pk
+        if cover_pk:
+            kwargs = {"pk": cover_pk}
+            href = reverse("opds:bin:cover", kwargs=kwargs)
+        elif cover_pk == 0:
+            href = staticfiles_storage.url("img/missing_cover.webp")
+        else:
+            return None
+        return OPDS1Link(Rel.THUMBNAIL, href, "image/webp")
+
+    def _image_link(self):
+        if self.fake:
+            return None
+        cover_pk = self.obj.cover_pk
+        if cover_pk:
+            kwargs = {"pk": cover_pk, "page": 0}
+            href = reverse("opds:bin:page", kwargs=kwargs)
+            mime_type = "image/jpeg"
+        elif cover_pk == 0:
+            href = staticfiles_storage.url("img/missing_cover.webp")
+            mime_type = "image/webp"
+        else:
+            return None
+        return OPDS1Link(Rel.IMAGE, href, mime_type)
+
+    def _nav_href(self, metadata=False):
+        kwargs = {"group": self.obj.group, "pk": self.obj.pk, "page": 1}
+        href = reverse("opds:v1:feed", kwargs=kwargs)
+        qps = {}
+        if (
+            self.obj.group == "a"
+            and self.obj.pk
+            and not self.query_params.get("orderBy")
+        ):
+            # story arcs get ordered by story_arc_number by default
+            qps.update({"orderBy": "story_arc_number"})
+        if metadata:
+            qps.update({"opdsMetadata": 1})
+        return update_href_query_params(href, self.query_params, qps)
+
+    def _nav_link(self, metadata=False):
+        group = self.obj.group
+
+        if group in self.acquision_groups:
+            mime_type = MimeType.ENTRY_CATALOG if metadata else MimeType.ACQUISITION
+        else:
+            mime_type = MimeType.NAV
+
+        href = self._nav_href(metadata)
+        thr_count = 0 if self.fake else self.obj.child_count
+        rel = Rel.ALTERNATE if metadata else "subsection"
+
+        return OPDS1Link(rel, href, mime_type, thr_count=thr_count)
+
+    def _download_link(self):
+        pk = self.obj.pk
+        if not pk:
+            return None
+        fn = Comic.get_filename(self.obj)
+        fn = quote_plus(fn)
+        kwargs = {"pk": pk, "filename": fn}
+        href = reverse("opds:bin:download", kwargs=kwargs)
+        mime_type = self.mime_type_map.get(self.obj.file_type, MimeType.OCTET)
+        return OPDS1Link(Rel.ACQUISITION, href, mime_type, length=self.obj.size)
+
+    def _stream_link(self):
+        pk = self.obj.pk
+        if not pk:
+            return None
+        kwargs = {"pk": pk, "page": 0}
+        qps = {"bookmark": 1}
+        href = reverse("opds:bin:page", kwargs=kwargs)
+        href = update_href_query_params(href, {}, qps)
+        href = href.replace("0/page.jpg", "{pageNumber}/page.jpg")
+        page = self.obj.page
+        count = self.obj.page_count
+        bookmark_updated_at = self.obj.bookmark_updated_at
+        return OPDS1Link(
+            Rel.STREAM,
+            href,
+            MimeType.STREAM,
+            pse_count=count,
+            pse_last_read=page,
+            pse_last_read_date=bookmark_updated_at,
+        )
+
+    @property
+    def links(self):
+        """Create all entry links."""
+        result = []
+        if thumb := self._thumb_link():
+            result += [thumb]
+        if image := self._image_link():
+            result += [image]
+
+        if self.obj.group == "c" and not self.fake:
+            if download := self._download_link():
+                result += [download]
+            if stream := self._stream_link():
+                result += [stream]
+            if not self.metadata and (metadata := self._nav_link(metadata=True)):
+                result += [metadata]
+        elif nav := self._nav_link():
+            result += [nav]
+
+        return result

codex/views/opds/v1/facets.py

@@ -0,0 +1,190 @@
+"""OPDS v1 Facets methods."""
+from dataclasses import dataclass
+
+from django.urls import reverse
+
+from codex.models import AdminFlag
+from codex.views.browser.browser import BrowserView
+from codex.views.opds.const import MimeType, Rel
+from codex.views.opds.util import update_href_query_params
+from codex.views.opds.v1.data import OPDS1Link
+from codex.views.opds.v1.entry.data import OPDS1EntryData, OPDS1EntryObject
+from codex.views.opds.v1.entry.entry import OPDS1Entry
+
+
+@dataclass
+class FacetGroup:
+    """An opds:facetGroup."""
+
+    title_prefix: str
+    query_param: str
+    glyph: str
+    facets: tuple
+
+
+@dataclass
+class Facet:
+    """An OPDS facet."""
+
+    value: str
+    title: str
+
+
+class FacetGroups:
+    """Facet Group definitions."""
+
+    ORDER_BY = FacetGroup(
+        "Order By",
+        "orderBy",
+        "➠",
+        (
+            Facet("date", "Date"),
+            Facet("sort_name", "Name"),
+        ),
+    )
+    ORDER_REVERSE = FacetGroup(
+        "Order",
+        "orderReverse",
+        "⇕",
+        (Facet("false", "Ascending"), Facet("true", "Descending")),
+    )
+    ALL = (ORDER_BY, ORDER_REVERSE)
+
+
+class RootFacetGroups:
+    """Facet Groups that only appear at the root."""
+
+    TOP_GROUP = FacetGroup(
+        "",
+        "topGroup",
+        "⊙",
+        (
+            Facet("p", "Publishers View"),
+            Facet("s", "Series View"),
+            Facet("f", "Folder View"),
+            Facet("a", "Story Arc View"),
+        ),
+    )
+    ALL = (TOP_GROUP,)
+
+
+DEFAULT_FACETS = {
+    "topGroup": "p",
+    "orderBy": "sort_name",
+    "orderReverse": "false",
+}
+
+
+class FacetsMixin(BrowserView):
+    """OPDS 1 Facets methods."""
+
+    # Overwritten by get_object()
+    use_facets = False
+    skip_order_facets = False
+    acquisition_groups = frozenset()
+    mime_type_map = MimeType.FILE_TYPE_MAP
+    obj = {}
+
+    def _facet(self, kwargs, facet_group, facet_title, new_query_params):
+        href = reverse("opds:v1:feed", kwargs=kwargs)
+        facet_active = False
+        for key, val in new_query_params.items():
+            if self.request.query_params.get(key) == val:
+                facet_active = True
+                break
+        href = update_href_query_params(
+            href, self.request.query_params, new_query_params
+        )
+
+        title = " ".join(filter(None, (facet_group.title_prefix, facet_title))).strip()
+        return OPDS1Link(
+            Rel.FACET,
+            href,
+            MimeType.NAV,
+            title=title,
+            facet_group=facet_group.query_param,
+            facet_active=facet_active,
+        )
+
+    def _facet_entry(self, item, facet_group, facet, query_params):
+        name = " ".join(
+            filter(None, (facet_group.glyph, facet_group.title_prefix, facet.title))
+        ).strip()
+        entry_obj = OPDS1EntryObject(
+            group=item.get("group"),
+            pk=item.get("pk"),
+            name=name,
+        )
+        qps = {**self.request.query_params}
+        qps.update(query_params)
+        issue_max = self.obj.get("issue_max", 0)
+        data = OPDS1EntryData(
+            self.acquisition_groups, issue_max, False, self.mime_type_map
+        )
+        return OPDS1Entry(entry_obj, qps, data)
+
+    def _is_facet_active(self, facet_group, facet):
+        compare = [facet.value]
+        default_val = DEFAULT_FACETS.get(facet_group.query_param)
+        if facet.value == default_val:
+            compare += [None]
+        return self.request.query_params.get(facet_group.query_param) in compare
+
+    @staticmethod
+    def _did_special_group_change(group, facet_group):
+        """Test if one of the special groups changed."""
+        for test_group in ("f", "a"):
+            if (
+                group == test_group
+                and facet_group != test_group
+                or group != test_group
+                and facet_group == test_group
+            ):
+                return True
+        return False
+
+    def _facet_or_facet_entry(self, facet_group, facet, entries):
+        # This logic preempts facet:activeFacet but no one uses it.
+        # don't add default facets if in default mode.
+        if self._is_facet_active(facet_group, facet):
+            return None
+
+        group = self.kwargs.get("group")
+        if facet_group.query_param == "topGroup" and self._did_special_group_change(
+            group, facet.value
+        ):
+            kwargs = {"group": facet.value, "pk": 0, "page": 1}
+        else:
+            kwargs = self.kwargs
+
+        qps = {facet_group.query_param: facet.value}
+        if entries and self.kwargs.get("page") == 1:
+            facet = self._facet_entry(kwargs, facet_group, facet, qps)
+        else:
+            facet = self._facet(kwargs, facet_group, facet.title, qps)
+        return facet
+
+    def _facet_group(self, facet_group, entries):
+        facets = []
+        for facet in facet_group.facets:
+            if facet.value == "f":
+                efv_flag = (
+                    AdminFlag.objects.only("on")
+                    .get(key=AdminFlag.FlagChoices.FOLDER_VIEW.value)
+                    .on
+                )
+                if not efv_flag:
+                    continue
+            if facet_obj := self._facet_or_facet_entry(facet_group, facet, entries):
+                facets += [facet_obj]
+        return facets
+
+    def facets(self, entries=False, root=True):
+        """Return facets."""
+        facets = []
+        if not self.skip_order_facets:
+            facets += self._facet_group(FacetGroups.ORDER_BY, entries)
+            facets += self._facet_group(FacetGroups.ORDER_REVERSE, entries)
+        if root:
+            facets += self._facet_group(RootFacetGroups.TOP_GROUP, entries)
+        return facets