codex 1.6.0a5__py3-none-any.whl → 1.6.0a7__py3-none-any.whl

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,70 @@
+"""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.utils 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 _get_group_mtime(self, group, pks, use_bookmark_filter):
+        """Get one group's mtimes."""
+        model = GROUP_MODEL_MAP[group]
+        if not model:
+            model = Publisher
+
+        qs = model.objects
+
+        if pks and 0 not in pks:
+            qs = qs.filter(pk__in=pks)
+        updated_at_max = qs.aggregate(max=Max("updated_at"))["max"]
+
+        if use_bookmark_filter:
+            bm_rel = self.get_bm_rel(model)
+            bm_filter = self.get_my_bookmark_filter(bm_rel)
+            qs = qs.filter(bm_filter)
+            # TODO can these be combined into one max?
+            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, groups, use_bookmark_filter):
+        """Get max mtime for all groups."""
+        max_mtime = None
+
+        for item in groups:
+            group = item["group"]
+            pks = tuple(int(pk) for pk in item["pks"].split(","))
+            mtime = self._get_group_mtime(group, pks, use_bookmark_filter)
+            max_mtime = max_none(max_mtime, mtime)
+        return max_mtime
+
+    def get(self, *args, **kwargs):
+        """Get the mtimes for the submitted groups."""
+        # Parse Request
+        params = reparse_json_query_params(self.request.GET, _REPARSE_JSON_FIELDS)
+        groups = params.get("groups", "")
+        use_bookmark_filter = self.request.GET.get("use_bookmark_filter", False)
+
+        max_mtime = self.get_max_groups_mtime(groups, use_bookmark_filter)
+
+        # 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."""

codex/views/opds/authentication_v1.py

@@ -9,57 +9,58 @@ from rest_framework.response import Response
 
 from codex.serializers.opds.authentication import OPDSAuthentication1Serializer
 
+_LOGO_SIZE = 512
+_DOC = MappingProxyType(
+    {
+        "id": reverse_lazy("opds:authentication:v1"),
+        "title": "Codex",
+        "description": "Codex OPDS Syndication",
+        "links": [
+            {
+                "rel": "logo",
+                "href": staticfiles_storage.url("img/logo.svg"),
+                "type": "image/svg+xml",
+                "width": _LOGO_SIZE,
+                "height": _LOGO_SIZE,
+            },
+            {
+                "rel": "help",
+                "href": "https://github.com/ajslater/codex",
+                "type": "text/html",
+            },
+            {
+                "rel": "register",
+                "href": reverse_lazy("app:start"),
+                "type": "text/html",
+            },
+        ],
+        "authentication": [
+            {
+                "type": "http://opds-spec.org/auth/basic",
+                "labels": {"login": "Username", "password": "Password"},
+            },
+            {
+                # XXX Out of spec type
+                "type": "cookie",
+                "links": [
+                    {
+                        "rel": "authenticate",
+                        "href": reverse_lazy("app:start"),
+                        "type": "text/html",
+                    }
+                ],
+            },
+        ],
+    }
+)
+
 
 class OPDSAuthentication1View(GenericAPIView):
     """Authentication document."""
 
     serializer_class = OPDSAuthentication1Serializer
 
-    DOC = MappingProxyType(
-        {
-            "id": reverse_lazy("opds:authentication:v1"),
-            "title": "Codex",
-            "description": "Codex OPDS Syndication",
-            "links": [
-                {
-                    "rel": "logo",
-                    "href": staticfiles_storage.url("img/logo.svg"),
-                    "type": "image/svg+xml",
-                    "width": 512,
-                    "height": 512,
-                },
-                {
-                    "rel": "help",
-                    "href": "https://github.com/ajslater/codex",
-                    "type": "text/html",
-                },
-                {
-                    "rel": "register",
-                    "href": reverse_lazy("app:start"),
-                    "type": "text/html",
-                },
-            ],
-            "authentication": [
-                {
-                    "type": "http://opds-spec.org/auth/basic",
-                    "labels": {"login": "Username", "password": "Password"},
-                },
-                {
-                    # XXX Out of spec type
-                    "type": "cookie",
-                    "links": [
-                        {
-                            "rel": "authenticate",
-                            "href": reverse_lazy("app:start"),
-                            "type": "text/html",
-                        }
-                    ],
-                },
-            ],
-        }
-    )
-
     def get(self, *args, **kwargs):
         """Fill in the authentication dict."""
-        serializer = self.get_serializer(self.DOC)
+        serializer = self.get_serializer(_DOC)
         return Response(serializer.data)

codex/views/opds/binary.py

@@ -1,21 +1,16 @@
 """Binary views with Basic Authentication added."""
 
-from rest_framework.authentication import BasicAuthentication, SessionAuthentication
-
 from codex.views.cover import CoverView
 from codex.views.download import DownloadView
+from codex.views.opds.auth import OPDSAuthMixin
 from codex.views.reader.page import ReaderPageView
 
 
-class OPDSAuthMixin:
-    """Add Basic Auth."""
-
-    authentication_classes = (BasicAuthentication, SessionAuthentication)
-
-
-class OPDSCoverView(OPDSAuthMixin, CoverView):
+class OPDSCoverView(CoverView):
     """Cover View with Basic Auth."""
 
+    # Panels sometimes doesn't send auth with cover requests.
+
 
 class OPDSDownloadView(OPDSAuthMixin, DownloadView):
     """Download View with Basic Auth."""

codex/views/opds/const.py

@@ -3,6 +3,16 @@
 from collections.abc import Mapping
 from types import MappingProxyType
 
+from codex.models import (
+    Character,
+    Genre,
+    Location,
+    SeriesGroup,
+    StoryArc,
+    Tag,
+    Team,
+)
+
 BLANK_TITLE = "Unknown"
 AUTHOR_ROLES = {"Writer"}
 
@@ -71,3 +81,6 @@ class MimeType:
         }
     )
     OCTET = "application/octet-stream"
+
+
+OPDS_M2M_MODELS = (Character, Genre, Location, SeriesGroup, StoryArc, Tag, Team)

codex/views/opds/urls.py

@@ -1,16 +1,16 @@
 """OPDS URLs."""
 
 from django.urls import reverse
-from rest_framework.generics import GenericAPIView
 from rest_framework.response import Response
 
 from codex.serializers.choices import DEFAULTS
 from codex.serializers.opds.urls import OPDSURLsSerializer
+from codex.views.auth import AuthGenericAPIView
 
-OPDS_VERSIONS = (1, 2)
+_OPDS_VERSIONS = (1, 2)
 
 
-class OPDSURLsView(GenericAPIView):
+class OPDSURLsView(AuthGenericAPIView):
     """OPDS URLs."""
 
     serializer_class = OPDSURLsSerializer
@@ -19,7 +19,8 @@ class OPDSURLsView(GenericAPIView):
         """Resolve the urls."""
         obj = {}
         route = DEFAULTS["breadcrumbs"][0]
-        for version in OPDS_VERSIONS:
+        route.pop("name", None)
+        for version in _OPDS_VERSIONS:
             key = f"v{version}"
             name = f"opds:v{version}:feed"
             value = reverse(name, kwargs=route)

codex/views/opds/util.py

@@ -6,19 +6,12 @@ from django.urls import reverse
 from django.utils.http import urlencode
 
 from codex.models import (
-    Character,
     Contributor,
     ContributorPerson,
-    Genre,
-    Location,
-    SeriesGroup,
     StoryArc,
-    Tag,
-    Team,
 )
 from codex.serializers.choices import DEFAULTS
-
-OPDS_M2M_MODELS = (Character, Genre, Location, SeriesGroup, StoryArc, Tag, Team)
+from codex.views.opds.const import OPDS_M2M_MODELS
 
 
 def update_href_query_params(href, old_query_params, new_query_params=None):
@@ -81,6 +74,7 @@ def full_redirect_view(url_name):
     def func(request):
         """Redirect to view, forwarding query strings and auth."""
         kwargs = DEFAULTS["breadcrumbs"][0]
+        kwargs.pop("name", None)
         url = reverse(url_name, kwargs=kwargs)
 
         # Forward the query string.

codex/views/opds/v1/facets.py

@@ -77,7 +77,7 @@ DEFAULT_FACETS = {
 }
 
 
-class FacetsMixin(BrowserView):
+class OPDS1FacetsView(BrowserView):
     """OPDS 1 Facets methods."""
 
     OPDS = 1
@@ -89,15 +89,14 @@ class FacetsMixin(BrowserView):
     obj = MappingProxyType({})
 
     def _facet(self, kwargs, facet_group, facet_title, new_query_params):
+        kwargs.pop("name", None)
         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:
+            if self.request.GET.get(key) == val:
                 facet_active = True
                 break
-        href = update_href_query_params(
-            href, self.request.query_params, new_query_params
-        )
+        href = update_href_query_params(href, self.request.GET, new_query_params)
 
         title = " ".join(filter(None, (facet_group.title_prefix, facet_title))).strip()
         return OPDS1Link(
@@ -118,7 +117,7 @@ class FacetsMixin(BrowserView):
             ids=item.get("pks"),
             name=name,
         )
-        qps = {**self.request.query_params}
+        qps = {**self.request.GET}
         qps.update(query_params)
         zero_pad = self.obj["zero_pad"]
         data = OPDS1EntryData(
@@ -131,7 +130,7 @@ class FacetsMixin(BrowserView):
         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
+        return self.request.GET.get(facet_group.query_param) in compare
 
     @staticmethod
     def _did_special_group_change(group, facet_group):

codex/views/opds/v1/feed.py

@@ -1,12 +1,10 @@
 """OPDS v1 feed."""
 
-from datetime import datetime, timezone
 from types import MappingProxyType
 from typing import TYPE_CHECKING, Any
 
 from comicbox.box import Comicbox
 from drf_spectacular.utils import extend_schema
-from rest_framework.authentication import BasicAuthentication, SessionAuthentication
 from rest_framework.response import Response
 from rest_framework.throttling import ScopedRateThrottle
 
@@ -17,17 +15,16 @@ from codex.serializers.opds.v1 import (
     OPDS1TemplateSerializer,
 )
 from codex.views.browser.browser import BrowserView
-from codex.views.browser.const import MAX_OBJ_PER_PAGE
-from codex.views.const import FALSY
+from codex.views.const import FALSY, MAX_OBJ_PER_PAGE
+from codex.views.opds.auth import OPDSTemplateView
 from codex.views.opds.const import BLANK_TITLE, MimeType
 from codex.views.opds.v1.entry.data import OPDS1EntryData
 from codex.views.opds.v1.entry.entry import OPDS1Entry
 from codex.views.opds.v1.links import (
-    LinksMixin,
+    OPDS1LinksView,
     RootTopLinks,
     TopLinks,
 )
-from codex.views.template import CodexXMLTemplateView
 
 if TYPE_CHECKING:
     from collections.abc import Mapping
@@ -54,10 +51,9 @@ class UserAgentPrefixes:
     # "Panels", "Chunky"
 
 
-class OPDS1FeedView(CodexXMLTemplateView, LinksMixin):
+class OPDS1FeedView(OPDS1LinksView, OPDSTemplateView):
     """OPDS 1 Feed."""
 
-    authentication_classes = (SessionAuthentication, BasicAuthentication)
     template_name = "opds_v1/index.xml"
     serializer_class = OPDS1TemplateSerializer
     throttle_classes = (ScopedRateThrottle,)
@@ -90,7 +86,7 @@ class OPDS1FeedView(CodexXMLTemplateView, LinksMixin):
         """Create the feed title."""
         result = ""
         try:
-            browser_title: Mapping[str, Any] = self.obj.get("browser_title")  # type: ignore
+            browser_title: Mapping[str, Any] = self.obj.get("title")  # type: ignore
             if browser_title:
                 parent_name = browser_title.get("parent_name", "All")
                 pks = self.kwargs["pks"]
@@ -107,10 +103,9 @@ class OPDS1FeedView(CodexXMLTemplateView, LinksMixin):
 
     @property
     def updated(self):
-        """Hack in feed update time from cover timestamp."""
+        """Use mtime for updated."""
         try:
-            if ts := self.obj.get("covers_timestamp"):
-                return datetime.fromtimestamp(ts, tz=timezone.utc)  # type: ignore
+            return self.obj.get("mtime", "")
         except Exception:
             LOG.exception("Getting OPDS v1 updated")
 
@@ -145,7 +140,7 @@ class OPDS1FeedView(CodexXMLTemplateView, LinksMixin):
                 entries += [
                     OPDS1Entry(
                         obj,
-                        self.request.query_params,
+                        self.request.GET,
                         data,
                         title_filename_fallback=fallback,
                     )
@@ -165,9 +160,7 @@ class OPDS1FeedView(CodexXMLTemplateView, LinksMixin):
                 entries += self.facets(entries=True, root=at_root)
 
             entries += self._get_entries_section("groups", False)
-            metadata = (
-                self.request.query_params.get("opdsMetadata", "").lower() not in FALSY
-            )
+            metadata = self.request.GET.get("opdsMetadata", "").lower() not in FALSY
             entries += self._get_entries_section("books", metadata)
         except Exception:
             LOG.exception("Getting OPDS v1 entries")
@@ -232,7 +225,7 @@ class OPDS1FeedView(CodexXMLTemplateView, LinksMixin):
             self.acquisition_groups = frozenset({*self.valid_nav_groups[-2:]} | {"c"})
             self.is_opds_1_acquisition = group in self.acquisition_groups
         self.is_opds_metadata = (
-            self.request.query_params.get("opdsMetadata", "").lower() not in FALSY
+            self.request.GET.get("opdsMetadata", "").lower() not in FALSY
         )
 
     def init_request(self):

codex/views/opds/v1/links.py

@@ -14,7 +14,7 @@ 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
-from codex.views.opds.v1.facets import FacetsMixin
+from codex.views.opds.v1.facets import OPDS1FacetsView
 
 LOG = get_logger(__name__)
 
@@ -101,13 +101,13 @@ class RootTopLinks:
     ALL = (NEW, FEATURED, LAST_READ)
 
 
-class LinksMixin(FacetsMixin):
+class OPDS1LinksView(OPDS1FacetsView):
     """OPDS 1 Links methods."""
 
     # overwritten in get_object()
     DEFAULT_ROUTE = MappingProxyType(
         {
-            **FacetsMixin.DEFAULT_ROUTE,
+            **OPDS1FacetsView.DEFAULT_ROUTE,
             "name": "opds:v1:feed",
         }
     )
@@ -120,7 +120,7 @@ class LinksMixin(FacetsMixin):
                 return False
 
         for key, value in top_link.query_params.items():
-            if str(self.request.query_params.get(key)) != str(value):
+            if str(self.request.GET.get(key)) != str(value):
                 return False
 
         return True
@@ -128,7 +128,8 @@ class LinksMixin(FacetsMixin):
     def _link(self, kwargs, rel, query_params=None, mime_type=MimeType.NAV):
         """Create a link."""
         if query_params is None:
-            query_params = self.request.query_params
+            query_params = self.request.GET
+        kwargs.pop("name", None)
         href = reverse("opds:v1:feed", kwargs=kwargs)
         href = update_href_query_params(href, query_params)
         return OPDS1Link(rel, href, mime_type)

codex/views/opds/v1/opensearch_v1.py

@@ -2,19 +2,15 @@
 
 from drf_spectacular.types import OpenApiTypes
 from drf_spectacular.utils import extend_schema
-from rest_framework.authentication import BasicAuthentication, SessionAuthentication
 from rest_framework.throttling import ScopedRateThrottle
 
-from codex.views.auth import IsAuthenticatedOrEnabledNonUsers
-from codex.views.template import CodexXMLTemplateView
+from codex.views.opds.auth import OPDSTemplateView
 
 
 @extend_schema(responses={("200", "application/xml"): OpenApiTypes.BYTE})
-class OpenSearch1View(CodexXMLTemplateView):
+class OpenSearch1View(OPDSTemplateView):
     """OpenSearchView."""
 
-    authentication_classes = (SessionAuthentication, BasicAuthentication)
-    permission_classes = (IsAuthenticatedOrEnabledNonUsers,)
     template_name = "opds_v1/opensearch_v1.xml"
     content_type = "application/xml"
     throttle_classes = (ScopedRateThrottle,)

codex/views/opds/v2/feed.py

@@ -3,15 +3,14 @@
 from types import MappingProxyType
 
 from drf_spectacular.utils import extend_schema
-from rest_framework.authentication import BasicAuthentication, SessionAuthentication
 from rest_framework.response import Response
 
 from codex.logger.logging import get_logger
 from codex.models import AdminFlag
 from codex.serializers.opds.v2 import OPDS2FeedSerializer
 from codex.views.browser.browser import BrowserView
-from codex.views.browser.const import MAX_OBJ_PER_PAGE
-from codex.views.const import FALSY
+from codex.views.const import FALSY, MAX_OBJ_PER_PAGE
+from codex.views.opds.auth import OPDSAuthMixin
 from codex.views.opds.const import BLANK_TITLE
 from codex.views.opds.v2.const import (
     FACETS,
@@ -22,22 +21,20 @@ from codex.views.opds.v2.const import (
     NavigationGroup,
 )
 from codex.views.opds.v2.links import HrefData, LinkData
-from codex.views.opds.v2.publications import PublicationMixin
-from codex.views.opds.v2.top_links import TopLinksMixin
+from codex.views.opds.v2.publications import OPDS2PublicationView
 
 LOG = get_logger(__name__)
 
 
-class OPDS2FeedView(PublicationMixin, TopLinksMixin):
+class OPDS2FeedView(OPDSAuthMixin, OPDS2PublicationView):
     """OPDS 2.0 Feed."""
 
     DEFAULT_ROUTE = MappingProxyType(
-        {**TopLinksMixin.DEFAULT_ROUTE, "name": "opds:v2:feed"}
+        {**OPDS2PublicationView.DEFAULT_ROUTE, "name": "opds:v2:feed"}
     )
     TARGET = "opds2"
     throttle_scope = "opds"
 
-    authentication_classes = (SessionAuthentication, BasicAuthentication)
     serializer_class = OPDS2FeedSerializer
 
     def _title(self, browser_title):
@@ -55,11 +52,11 @@ class OPDS2FeedView(PublicationMixin, TopLinksMixin):
             result = BLANK_TITLE
         return result
 
-    def _detect_user_agent(self):
-        """Hacks for individual clients."""
-        user_agent = self.request.headers.get("User-Agent")
-        if not user_agent:
-            return
+    # def _detect_user_agent(self):
+    #    """Hacks for individual clients."""
+    #    user_agent = self.request.headers.get("User-Agent")
+    #    if not user_agent:
+    #        return
 
     @staticmethod
     def _is_allowed(link_spec):
@@ -187,7 +184,7 @@ class OPDS2FeedView(PublicationMixin, TopLinksMixin):
         self.num_pages = browser_page["num_pages"]
 
         # opds page
-        title = self._title(browser_page.get("browser_title"))
+        title = self._title(browser_page.get("title"))
         number_of_items = browser_page["total_count"]
         current_page = self.kwargs.get("page")
         up_route = self.get_last_route()
@@ -224,7 +221,7 @@ class OPDS2FeedView(PublicationMixin, TopLinksMixin):
             acquisition_groups = frozenset(self.valid_nav_groups[-2:])
             self.is_opds_2_acquisition = group in acquisition_groups
         self.is_opds_metadata = (
-            self.request.query_params.get("opdsMetadata", "").lower() not in FALSY
+            self.request.GET.get("opdsMetadata", "").lower() not in FALSY
         )
 
     def init_request(self):

codex/views/opds/v2/links.py

@@ -39,7 +39,7 @@ class LinkData:
     num_items: int | None = None
 
 
-class LinksMixin(BrowserView):
+class OPDS2LinksView(BrowserView):
     """Links methods for OPDS 2.0 Feed."""
 
     num_pages = 0  # For pyright. Overwritten every run.
@@ -58,7 +58,7 @@ class LinksMixin(BrowserView):
         elif hasattr(self, "request"):
             # if request link and not init static links
             href = update_href_query_params(
-                href, self.request.query_params, new_query_params=data.query_params
+                href, self.request.GET, new_query_params=data.query_params
             )
         return href
 
@@ -69,6 +69,7 @@ class LinksMixin(BrowserView):
         if "page" in kwargs and not self._href_page_validate(kwargs, data):
             return None
 
+        kwargs.pop("name", None)
         href = reverse(url_name, kwargs=kwargs)
         return self._href_update_query_params(href, data)